diff --git a/src/window.cpp b/src/window.cpp
index 29612c8883..cb1f770522 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -1587,8 +1587,6 @@ void Window::maximize(MaximizeMode m)
 
 void Window::setMaximize(bool vertically, bool horizontally)
 {
-    // changeMaximize() flips the state, so change from set->flip
-    Q_EMIT clientMaximizedStateAboutToChange(this, MaximizeMode((vertically ? MaximizeVertical : 0) | (horizontally ? MaximizeHorizontal : 0)));
     const MaximizeMode oldMode = requestedMaximizeMode();
     changeMaximize(
         oldMode & MaximizeHorizontal ? !horizontally : horizontally,
diff --git a/src/x11window.cpp b/src/x11window.cpp
index f7b71d56c0..9cd83073a4 100644
--- a/src/x11window.cpp
+++ b/src/x11window.cpp
@@ -4307,39 +4307,43 @@ void X11Window::changeMaximize(bool horizontal, bool vertical, bool adjust)
 
     MaximizeMode old_mode = max_mode;
     // 'adjust == true' means to update the size only, e.g. after changing workspace size
+    MaximizeMode mode = max_mode;
     if (!adjust) {
         if (vertical) {
-            max_mode = MaximizeMode(max_mode ^ MaximizeVertical);
+            mode = MaximizeMode(mode ^ MaximizeVertical);
         }
         if (horizontal) {
-            max_mode = MaximizeMode(max_mode ^ MaximizeHorizontal);
+            mode = MaximizeMode(mode ^ MaximizeHorizontal);
         }
     }
 
     // if the client insist on a fix aspect ratio, we check whether the maximizing will get us
     // out of screen bounds and take that as a "full maximization with aspect check" then
     if (m_geometryHints.hasAspect() && // fixed aspect
-        (max_mode == MaximizeVertical || max_mode == MaximizeHorizontal) && // ondimensional maximization
+        (mode == MaximizeVertical || mode == MaximizeHorizontal) && // ondimensional maximization
         rules()->checkStrictGeometry(true)) { // obey aspect
         const QSize minAspect = m_geometryHints.minAspect();
         const QSize maxAspect = m_geometryHints.maxAspect();
-        if (max_mode == MaximizeVertical || (old_mode & MaximizeVertical)) {
+        if (mode == MaximizeVertical || (old_mode & MaximizeVertical)) {
             const double fx = minAspect.width(); // use doubles, because the values can be MAX_INT
             const double fy = maxAspect.height(); // use doubles, because the values can be MAX_INT
             if (fx * clientArea.height() / fy > clientArea.width()) { // too big
-                max_mode = old_mode & MaximizeHorizontal ? MaximizeRestore : MaximizeFull;
+                mode = old_mode & MaximizeHorizontal ? MaximizeRestore : MaximizeFull;
             }
-        } else { // max_mode == MaximizeHorizontal
+        } else { // mode == MaximizeHorizontal
             const double fx = maxAspect.width();
             const double fy = minAspect.height();
             if (fy * clientArea.width() / fx > clientArea.height()) { // too big
-                max_mode = old_mode & MaximizeVertical ? MaximizeRestore : MaximizeFull;
+                mode = old_mode & MaximizeVertical ? MaximizeRestore : MaximizeFull;
             }
         }
     }
 
-    max_mode = rules()->checkMaximize(max_mode);
-    if (!adjust && max_mode == old_mode) {
+    mode = rules()->checkMaximize(mode);
+    if (max_mode != mode) {
+        Q_EMIT clientMaximizedStateAboutToChange(this, mode);
+        max_mode = mode;
+    } else if (!adjust) {
         return;
     }
 
diff --git a/src/xdgshellwindow.cpp b/src/xdgshellwindow.cpp
index ca98b3350e..899c8ee3cb 100644
--- a/src/xdgshellwindow.cpp
+++ b/src/xdgshellwindow.cpp
@@ -1658,17 +1658,21 @@ void XdgToplevelWindow::changeMaximize(bool horizontal, bool vertical, bool adju
     const QRectF oldGeometry = moveResizeGeometry();
 
     // 'adjust == true' means to update the size only, e.g. after changing workspace size
+    MaximizeMode mode = m_requestedMaximizeMode;
     if (!adjust) {
         if (vertical) {
-            m_requestedMaximizeMode = MaximizeMode(m_requestedMaximizeMode ^ MaximizeVertical);
+            mode = MaximizeMode(mode ^ MaximizeVertical);
         }
         if (horizontal) {
-            m_requestedMaximizeMode = MaximizeMode(m_requestedMaximizeMode ^ MaximizeHorizontal);
+            mode = MaximizeMode(mode ^ MaximizeHorizontal);
         }
     }
 
-    m_requestedMaximizeMode = rules()->checkMaximize(m_requestedMaximizeMode);
-    if (!adjust && m_requestedMaximizeMode == oldMode) {
+    mode = rules()->checkMaximize(mode);
+    if (m_requestedMaximizeMode != mode) {
+        Q_EMIT clientMaximizedStateAboutToChange(this, mode);
+        m_requestedMaximizeMode = mode;
+    } else if (!adjust) {
         return;
     }