diff --git a/CHANGELOG.md b/CHANGELOG.md
index 812e483a..529ddabe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -46,6 +46,12 @@
 ## Unreleased
 ### Added
 ### Changed
+
+* When window is mapped, use metadata (DPI, scaling factor, subpixel
+  configuration) from the monitor we were most recently mapped on,
+  instead of the one least recently.
+
+
 ### Deprecated
 ### Removed
 ### Fixed
@@ -53,6 +59,14 @@
 * Use appropriate rounding when applying fractional scales.
 * Xcursor not being scaled correctly on `fractional-scale-v1` capable
   compositors.
+* `dpi-aware=yes` being broken on `fractional-scale-v1` capable
+  compositors (and when a fractional sacling factor is being used)
+  ([#1404][1404]).
+* Initial font size being wrong on `fractional-scale-v1` capable
+  compositors, with multiple monitors with different scaling factors
+  connected ([#1404][1404]).
+
+[1404]: https://codeberg.org/dnkl/foot/issues/1404
 
 
 ### Security
diff --git a/pgo/pgo.c b/pgo/pgo.c
index 6be60363..54618204 100644
--- a/pgo/pgo.c
+++ b/pgo/pgo.c
@@ -96,6 +96,7 @@ wayl_win_init(struct terminal *term, const char *token)
 void wayl_win_destroy(struct wl_window *win) {}
 void wayl_win_alpha_changed(struct wl_window *win) {}
 bool wayl_win_set_urgent(struct wl_window *win) { return true; }
+bool wayl_fractional_scaling(const struct wayland *wayl) { return true; }
 
 bool
 spawn(struct reaper *reaper, const char *cwd, char *const argv[],
diff --git a/render.c b/render.c
index c40d07d0..11149b16 100644
--- a/render.c
+++ b/render.c
@@ -3841,21 +3841,7 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
     if (term->cell_width == 0 && term->cell_height == 0)
         return false;
 
-    float scale = -1;
-    if (wayl_fractional_scaling(term->wl)) {
-        scale = term->window->scale;
-    } else {
-        tll_foreach(term->window->on_outputs, it) {
-            if (it->item->scale > scale)
-                scale = it->item->scale;
-        }
-    }
-
-    if (scale < 0.) {
-        /* Haven't 'entered' an output yet? */
-        scale = term->scale;
-    }
-
+    const float scale = term->scale;
     width = round(width * scale);
     height = round(height * scale);
 
@@ -3942,9 +3928,9 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
     /* Drop out of URL mode */
     urls_reset(term);
 
+    LOG_DBG("resized: size=%dx%d (scale=%.2f)", width, height, term->scale);
     term->width = width;
     term->height = height;
-    term->scale = scale;
 
     const uint32_t scrollback_lines = term->render.scrollback_lines;
 
@@ -4148,12 +4134,11 @@ maybe_resize(struct terminal *term, int width, int height, bool force)
 
     sixel_reflow(term);
 
-#if defined(_DEBUG) && LOG_ENABLE_DBG
-    LOG_DBG("resize: %dx%d, grid: cols=%d, rows=%d "
+    LOG_DBG("resized: grid: cols=%d, rows=%d "
             "(left-margin=%d, right-margin=%d, top-margin=%d, bottom-margin=%d)",
-            term->width, term->height, term->cols, term->rows,
-            term->margins.left, term->margins.right, term->margins.top, term->margins.bottom);
-#endif
+            term->cols, term->rows,
+            term->margins.left, term->margins.right,
+            term->margins.top, term->margins.bottom);
 
     if (term->scroll_region.start >= term->rows)
         term->scroll_region.start = 0;
@@ -4295,7 +4280,7 @@ render_xcursor_update(struct seat *seat)
 #endif
 
     LOG_DBG("setting %scursor shape using a client-side cursor surface",
-            shape == CURSOR_SHAPE_CUSTOM ? "custom " : "");
+            seat->pointer.shape == CURSOR_SHAPE_CUSTOM ? "custom " : "");
 
     const float scale = seat->pointer.scale;
     struct wl_cursor_image *image = seat->pointer.cursor->images[0];
diff --git a/terminal.c b/terminal.c
index 485e8ca3..2f0e632c 100644
--- a/terminal.c
+++ b/terminal.c
@@ -733,7 +733,8 @@ term_line_height_update(struct terminal *term)
 }
 
 static bool
-term_set_fonts(struct terminal *term, struct fcft_font *fonts[static 4])
+term_set_fonts(struct terminal *term, struct fcft_font *fonts[static 4],
+               bool resize_grid)
 {
     for (size_t i = 0; i < 4; i++) {
         xassert(fonts[i] != NULL);
@@ -777,11 +778,15 @@ term_set_fonts(struct terminal *term, struct fcft_font *fonts[static 4])
 
     sixel_cell_size_changed(term);
 
-    /* Use force, since cell-width/height may have changed */
-    render_resize_force(
-        term,
-        round(term->width / term->scale),
-        round(term->height / term->scale));
+    /* Optimization - some code paths (are forced to) call
+     * render_resize() after this function */
+    if (resize_grid) {
+        /* Use force, since cell-width/height may have changed */
+        render_resize_force(
+            term,
+            round(term->width / term->scale),
+            round(term->height / term->scale));
+    }
     return true;
 }
 
@@ -796,41 +801,34 @@ get_font_dpi(const struct terminal *term)
      * Conceptually, we use the physical monitor specs to calculate
      * the DPI, and we ignore the output's scaling factor.
      *
-     * However, to deal with fractional scaling, where we're told to
-     * render at e.g. 2x, but are then downscaled by the compositor to
-     * e.g. 1.25, we use the scaled DPI value multiplied by the scale
-     * factor instead.
+     * However, to deal with legacy fractional scaling, where we're
+     * told to render at e.g. 2x, but are then downscaled by the
+     * compositor to e.g. 1.25, we use the scaled DPI value multiplied
+     * by the scale factor instead.
      *
      * For integral scaling factors the resulting DPI is the same as
      * if we had used the physical DPI.
      *
-     * For fractional scaling factors we'll get a DPI *larger* than
-     * the physical DPI, that ends up being right when later
+     * For legacy fractional scaling factors we'll get a DPI *larger*
+     * than the physical DPI, that ends up being right when later
      * downscaled by the compositor.
+     *
+     * With the newer fractional-scale-v1 protocol, we use the
+     * monitor’s real DPI, since we scale everything to the correct
+     * scaling factor (no downscaling done by the compositor).
      */
 
-    /* Use highest DPI from outputs we're mapped on */
-    double dpi = 0.0;
-    xassert(term->window != NULL);
-    tll_foreach(term->window->on_outputs, it) {
-        if (it->item->dpi > dpi)
-            dpi = it->item->dpi;
-    }
+    xassert(tll_length(term->wl->monitors) > 0);
 
-    /* If we're not mapped, use DPI from first monitor. Hopefully this is where we'll get mapped later... */
-    if (dpi == 0.) {
-        tll_foreach(term->wl->monitors, it) {
-            dpi = it->item.dpi;
-            break;
-        }
-    }
+    const struct wl_window *win = term->window;
+    const struct monitor *mon = tll_length(win->on_outputs) > 0
+        ? tll_back(win->on_outputs)
+        : &tll_front(term->wl->monitors);
 
-    if (dpi == 0) {
-        /* No monitors? */
-        dpi = 96.;
-    }
-
-    return dpi;
+    if (wayl_fractional_scaling(term->wl))
+        return mon->dpi.physical;
+    else
+        return mon->dpi.scaled;
 }
 
 static enum fcft_subpixel
@@ -849,7 +847,8 @@ get_font_subpixel(const struct terminal *term)
      * output or not.
      *
      * Thus, when determining which subpixel mode to use, we can't do
-     * much but select *an* output. So, we pick the first one.
+     * much but select *an* output. So, we pick the one we were most
+     * recently mapped on.
      *
      * If we're not mapped at all, we pick the first available
      * monitor, and hope that's where we'll eventually get mapped.
@@ -859,7 +858,7 @@ get_font_subpixel(const struct terminal *term)
      */
 
     if (tll_length(term->window->on_outputs) > 0)
-        wl_subpixel = tll_front(term->window->on_outputs)->subpixel;
+        wl_subpixel = tll_back(term->window->on_outputs)->subpixel;
     else if (tll_length(term->wl->monitors) > 0)
         wl_subpixel = tll_front(term->wl->monitors).subpixel;
     else
@@ -906,7 +905,7 @@ font_loader_thread(void *_data)
 }
 
 static bool
-reload_fonts(struct terminal *term)
+reload_fonts(struct terminal *term, bool resize_grid)
 {
     const struct config *conf = term->conf;
 
@@ -1033,7 +1032,7 @@ reload_fonts(struct terminal *term)
         }
     }
 
-    return success ? term_set_fonts(term, fonts) : success;
+    return success ? term_set_fonts(term, fonts, resize_grid) : success;
 }
 
 static bool
@@ -1051,7 +1050,7 @@ load_fonts_from_conf(struct terminal *term)
         }
     }
 
-    return reload_fonts(term);
+    return reload_fonts(term, true);
 }
 
 static void fdm_client_terminated(
@@ -1285,11 +1284,9 @@ term_init(const struct config *conf, struct fdm *fdm, struct reaper *reaper,
     reaper_add(term->reaper, term->slave, &fdm_client_terminated, term);
 
     /* Guess scale; we're not mapped yet, so we don't know on which
-     * output we'll be. Pick highest scale we find for now */
-    tll_foreach(term->wl->monitors, it) {
-        if (it->item.scale > term->scale)
-            term->scale = it->item.scale;
-    }
+     * output we'll be. Use scaling factor from first monitor */
+    xassert(tll_length(term->wl->monitors) > 0);
+    term->scale = tll_front(term->wl->monitors).scale;
 
     memcpy(term->colors.table, term->conf->colors.table, sizeof(term->colors.table));
 
@@ -1298,7 +1295,7 @@ term_init(const struct config *conf, struct fdm *fdm, struct reaper *reaper,
         goto err;
 
     /* Load fonts */
-    if (!term_font_dpi_changed(term, 0))
+    if (!term_font_dpi_changed(term, 0.))
         goto err;
 
     term->font_subpixel = get_font_subpixel(term);
@@ -1996,7 +1993,7 @@ term_font_size_adjust_by_points(struct terminal *term, float amount)
         }
     }
 
-    return reload_fonts(term);
+    return reload_fonts(term, true);
 }
 
 static bool
@@ -2019,7 +2016,7 @@ term_font_size_adjust_by_pixels(struct terminal *term, int amount)
         }
     }
 
-    return reload_fonts(term);
+    return reload_fonts(term, true);
 }
 
 static bool
@@ -2043,7 +2040,7 @@ term_font_size_adjust_by_percent(struct terminal *term, bool increment, float pe
         }
     }
 
-    return reload_fonts(term);
+    return reload_fonts(term, true);
 }
 
 bool
@@ -2081,10 +2078,40 @@ term_font_size_reset(struct terminal *term)
 }
 
 bool
-term_font_dpi_changed(struct terminal *term, int old_scale)
+term_update_scale(struct terminal *term)
+{
+    const struct wl_window *win = term->window;
+
+    /*
+     * We have a number of “sources” we can use as scale. We choose
+     * the scale in the following order:
+     *
+     *  - “preferred” scale, from the fractional-scale-v1 protocol
+     *  - scaling factor of output we most recently were mapped on
+     *  - if we’re not mapped, use the scaling factor from the first
+     *    available output.
+     *  - if there aren’t any outputs available, use 1.0
+     */
+    const float new_scale =
+        (wayl_fractional_scaling(term->wl) && win->scale > 0.
+         ? win->scale
+         : (tll_length(win->on_outputs) > 0
+            ? tll_back(win->on_outputs)->scale
+            : 1.));
+
+    if (new_scale == term->scale)
+        return false;
+
+    LOG_DBG("scaling factor changed: %.2f -> %.2f", term->scale, new_scale);
+    term->scale = new_scale;
+    return true;
+}
+
+bool
+term_font_dpi_changed(struct terminal *term, float old_scale)
 {
     float dpi = get_font_dpi(term);
-    xassert(term->scale > 0);
+    xassert(term->scale > 0.);
 
     bool was_scaled_using_dpi = term->font_is_sized_by_dpi;
     bool will_scale_using_dpi = term->conf->dpi_aware;
@@ -2096,11 +2123,10 @@ term_font_dpi_changed(struct terminal *term, int old_scale)
          : old_scale != term->scale);
 
     if (need_font_reload) {
-        LOG_DBG("DPI/scale change: DPI-awareness=%s, "
-                "DPI: %.2f -> %.2f, scale: %d -> %d, "
+        LOG_DBG("DPI/scale change: DPI-aware=%s, "
+                "DPI: %.2f -> %.2f, scale: %.2f -> %.2f, "
                 "sizing font based on monitor's %s",
-                term->conf->dpi_aware == DPI_AWARE_AUTO ? "auto" :
-                term->conf->dpi_aware == DPI_AWARE_YES ? "yes" : "no",
+                term->conf->dpi_aware ? "yes" : "no",
                 term->font_dpi, dpi, old_scale, term->scale,
                 will_scale_using_dpi ? "DPI" : "scaling factor");
     }
@@ -2109,9 +2135,9 @@ term_font_dpi_changed(struct terminal *term, int old_scale)
     term->font_is_sized_by_dpi = will_scale_using_dpi;
 
     if (!need_font_reload)
-        return true;
+        return false;
 
-    return reload_fonts(term);
+    return reload_fonts(term, false);
 }
 
 void
@@ -3510,7 +3536,7 @@ term_update_ascii_printer(struct terminal *term)
 
 #if defined(_DEBUG) && LOG_ENABLE_DBG
     if (term->ascii_printer != new_printer) {
-        LOG_DBG("§switching ASCII printer %s -> %s",
+        LOG_DBG("switching ASCII printer %s -> %s",
                 term->ascii_printer == &ascii_printer_fast ? "fast" : "generic",
                 new_printer == &ascii_printer_fast ? "fast" : "generic");
     }
diff --git a/terminal.h b/terminal.h
index 6dace7ac..4b1d1d0d 100644
--- a/terminal.h
+++ b/terminal.h
@@ -736,10 +736,11 @@ bool term_to_slave(struct terminal *term, const void *data, size_t len);
 bool term_paste_data_to_slave(
     struct terminal *term, const void *data, size_t len);
 
+bool term_update_scale(struct terminal *term);
 bool term_font_size_increase(struct terminal *term);
 bool term_font_size_decrease(struct terminal *term);
 bool term_font_size_reset(struct terminal *term);
-bool term_font_dpi_changed(struct terminal *term, int old_scale);
+bool term_font_dpi_changed(struct terminal *term, float old_scale);
 void term_font_subpixel_changed(struct terminal *term);
 
 int term_pt_or_px_as_pixels(
diff --git a/wayland.c b/wayland.c
index 9195797e..354a0e78 100644
--- a/wayland.c
+++ b/wayland.c
@@ -396,17 +396,35 @@ static const struct wl_seat_listener seat_listener = {
 static void
 update_term_for_output_change(struct terminal *term)
 {
-    if (tll_length(term->window->on_outputs) == 0)
-        return;
+    const float old_scale = term->scale;
+    const float logical_width = term->width / term->scale;
+    const float logical_height = term->height / term->scale;
 
-    float old_scale = term->scale;
-
-    render_resize(term,
-                  round(term->width / term->scale),
-                  round(term->height / term->scale));
-    term_font_dpi_changed(term, old_scale);
+    /* Note: order matters! term_update_scale() must come first */
+    bool scale_updated = term_update_scale(term);
+    bool fonts_updated = term_font_dpi_changed(term, old_scale);
     term_font_subpixel_changed(term);
+
     csd_reload_font(term->window, old_scale);
+
+    if (fonts_updated) {
+        /*
+         * If the fonts have been updated, the cell dimensions have
+         * changed. This requires a “forced” resize, since the surface
+         * buffer dimensions may not have been updated (in which case
+         * render_size() normally shortcuts and returns early).
+         */
+        render_resize_force(term, round(logical_width), round(logical_height));
+    }
+
+    else if (scale_updated) {
+        /*
+         * A scale update means the surface buffer dimensions have
+         * been updated, even though the window logical dimensions
+         * haven’t changed.
+         */
+        render_resize(term, round(logical_width), round(logical_height));
+    }
 }
 
 static void
@@ -435,6 +453,9 @@ output_update_ppi(struct monitor *mon)
     double x_inches = mon->dim.mm.width * 0.03937008;
     double y_inches = mon->dim.mm.height * 0.03937008;
 
+    const int width = mon->dim.px_real.width;
+    const int height = mon->dim.px_real.height;
+
     mon->ppi.real.x = mon->dim.px_real.width / x_inches;
     mon->ppi.real.y = mon->dim.px_real.height / y_inches;
 
@@ -457,27 +478,36 @@ output_update_ppi(struct monitor *mon)
         break;
     }
 
-    int scaled_width = mon->dim.px_scaled.width;
-    int scaled_height = mon->dim.px_scaled.height;
-
-    if (scaled_width == 0 && scaled_height == 0 && mon->scale > 0) {
-        /* Estimate scaled width/height if none has been provided */
-        scaled_width = mon->dim.px_real.width / mon->scale;
-        scaled_height = mon->dim.px_real.height / mon->scale;
-    }
+    const int scaled_width = mon->dim.px_scaled.width;
+    const int scaled_height = mon->dim.px_scaled.height;
 
     mon->ppi.scaled.x = scaled_width / x_inches;
     mon->ppi.scaled.y = scaled_height / y_inches;
 
-    double px_diag = sqrt(pow(scaled_width, 2) + pow(scaled_height, 2));
-    mon->dpi = px_diag / mon->inch * mon->scale;
+    const double px_diag_physical = sqrt(pow(width, 2) + pow(height, 2));
+    mon->dpi.physical = width == 0 && height == 0
+        ? 96.
+        : px_diag_physical / mon->inch;
 
-    if (mon->dpi > 1000) {
+    const double px_diag_scaled = sqrt(pow(scaled_width, 2) + pow(scaled_height, 2));
+    mon->dpi.scaled = scaled_width == 0 && scaled_height == 0
+        ? 96.
+        : px_diag_scaled / mon->inch * mon->scale;
+
+    if (mon->dpi.physical > 1000) {
         if (mon->name != NULL) {
-            LOG_WARN("%s: DPI=%f is unreasonable, using 96 instead",
-                     mon->name, mon->dpi);
+            LOG_WARN("%s: DPI=%f (physical) is unreasonable, using 96 instead",
+                     mon->name, mon->dpi.physical);
         }
-        mon->dpi = 96;
+        mon->dpi.physical = 96;
+    }
+
+    if (mon->dpi.scaled > 1000) {
+        if (mon->name != NULL) {
+            LOG_WARN("%s: DPI=%f (logical) is unreasonable, using 96 instead",
+                     mon->name, mon->dpi.scaled);
+        }
+        mon->dpi.scaled = 96;
     }
 }
 
@@ -1435,6 +1465,11 @@ wayl_init(struct fdm *fdm, struct key_binding_manager *key_binding_manager,
         LOG_ERR("no seats available (wl_seat interface too old?)");
         goto out;
     }
+    if (tll_length(wayl->monitors) == 0) {
+        LOG_ERR("no monitors available");
+        goto out;
+    }
+
     if (wayl->primary_selection_device_manager == NULL)
         LOG_WARN("no primary selection available");
 
@@ -1487,14 +1522,12 @@ wayl_init(struct fdm *fdm, struct key_binding_manager *key_binding_manager,
 
     tll_foreach(wayl->monitors, it) {
         LOG_INFO(
-            "%s: %dx%d+%dx%d@%dHz %s %.2f\" scale=%d PPI=%dx%d (physical) PPI=%dx%d (logical), DPI=%.2f",
+            "%s: %dx%d+%dx%d@%dHz %s %.2f\" scale=%d, DPI=%.2f/%.2f (physical/scaled)",
             it->item.name, it->item.dim.px_real.width, it->item.dim.px_real.height,
             it->item.x, it->item.y, (int)round(it->item.refresh),
             it->item.model != NULL ? it->item.model : it->item.description,
             it->item.inch, it->item.scale,
-            it->item.ppi.real.x, it->item.ppi.real.y,
-            it->item.ppi.scaled.x, it->item.ppi.scaled.y,
-            it->item.dpi);
+            it->item.dpi.physical, it->item.dpi.scaled);
     }
 
     wayl->fd = wl_display_get_fd(wayl->display);
@@ -1603,10 +1636,15 @@ static void fractional_scale_preferred_scale(
     uint32_t scale)
 {
     struct wl_window *win = data;
-    win->scale = (float)scale / 120.;
-    win->have_preferred_scale = true;
 
-    LOG_DBG("fractional scale: %.3f", win->scale);
+    const float new_scale = (float)scale / 120.;
+
+    if (win->scale == new_scale)
+        return;
+
+    LOG_DBG("fractional scale: %.2f -> %.2f", win->scale, new_scale);
+
+    win->scale = new_scale;
     update_term_for_output_change(win->term);
 }
 
@@ -1971,7 +2009,7 @@ wayl_surface_scale_explicit_width_height(
     int width, int height, float scale)
 {
 
-    if (wayl_fractional_scaling(win->term->wl) && win->have_preferred_scale) {
+    if (wayl_fractional_scaling(win->term->wl) && win->scale > 0.) {
 #if defined(HAVE_FRACTIONAL_SCALE)
         LOG_DBG("scaling by a factor of %.2f using fractional scaling "
                 "(width=%d, height=%d) ", scale, width, height);
diff --git a/wayland.h b/wayland.h
index 6d1cd727..275338a8 100644
--- a/wayland.h
+++ b/wayland.h
@@ -315,7 +315,10 @@ struct monitor {
         } scaled;
     } ppi;
 
-    float dpi;
+    struct {
+        float scaled;
+        float physical;
+    } dpi;
 
     int scale;
     float refresh;
@@ -374,7 +377,6 @@ struct wl_window {
     bool unmapped;
 
     float scale;
-    bool have_preferred_scale;
 
     struct zxdg_toplevel_decoration_v1 *xdg_toplevel_decoration;