diff --git a/GlazeWM.Domain/Containers/CommandHandlers/SyncNativeFocusHandler.cs b/GlazeWM.Domain/Containers/CommandHandlers/SyncNativeFocusHandler.cs
index 26cff51a5..8f8592b35 100644
--- a/GlazeWM.Domain/Containers/CommandHandlers/SyncNativeFocusHandler.cs
+++ b/GlazeWM.Domain/Containers/CommandHandlers/SyncNativeFocusHandler.cs
@@ -12,16 +12,11 @@ internal sealed class SyncNativeFocusHandler : ICommandHandler<SyncNativeFocusCo
   {
     private readonly Bus _bus;
     private readonly ContainerService _containerService;
-    private readonly WindowService _windowService;
 
-    public SyncNativeFocusHandler(
-      Bus bus,
-      ContainerService containerService,
-      WindowService windowService)
+    public SyncNativeFocusHandler(Bus bus, ContainerService containerService)
     {
       _bus = bus;
       _containerService = containerService;
-      _windowService = windowService;
     }
 
     public CommandResponse Handle(SyncNativeFocusCommand command)
@@ -37,7 +32,7 @@ public CommandResponse Handle(SyncNativeFocusCommand command)
       var handleToFocus = focusedContainer switch
       {
         Window window => window.Handle,
-        Workspace => _windowService.DesktopWindowHandle,
+        Workspace => GetDesktopWindow(),
         _ => throw new Exception("Invalid container type to focus. This is a bug."),
       };
 
@@ -49,6 +44,8 @@ public CommandResponse Handle(SyncNativeFocusCommand command)
       _bus.Emit(new NativeFocusSyncedEvent(focusedContainer));
       _bus.Emit(new FocusChangedEvent(focusedContainer));
 
+      _containerService.HasPendingFocusSync = false;
+
       return CommandResponse.Ok;
     }
   }
diff --git a/GlazeWM.Domain/Containers/ContainerService.cs b/GlazeWM.Domain/Containers/ContainerService.cs
index e7b68ed0d..4a6c6a877 100644
--- a/GlazeWM.Domain/Containers/ContainerService.cs
+++ b/GlazeWM.Domain/Containers/ContainerService.cs
@@ -44,12 +44,6 @@ public class ContainerService
     /// </summary>
     public string ActiveBindingMode { get; set; }
 
-    /// <summary>
-    /// If set, this container overrides the target container to set focus to on the next
-    /// focus window event (ie. `EVENT_SYSTEM_FOREGROUND`).
-    /// </summary>
-    public Container PendingFocusContainer { get; set; }
-
     private readonly UserConfigService _userConfigService;
 
     public ContainerService(UserConfigService userConfigService)
diff --git a/GlazeWM.Domain/Windows/CommandHandlers/UnmanageWindowHandler.cs b/GlazeWM.Domain/Windows/CommandHandlers/UnmanageWindowHandler.cs
index 5e2b56b14..a78b0e0a0 100644
--- a/GlazeWM.Domain/Windows/CommandHandlers/UnmanageWindowHandler.cs
+++ b/GlazeWM.Domain/Windows/CommandHandlers/UnmanageWindowHandler.cs
@@ -10,11 +10,16 @@ internal sealed class UnmanageWindowHandler : ICommandHandler<UnmanageWindowComm
   {
     private readonly Bus _bus;
     private readonly ContainerService _containerService;
+    private readonly WindowService _windowService;
 
-    public UnmanageWindowHandler(Bus bus, ContainerService containerService)
+    public UnmanageWindowHandler(
+      Bus bus,
+      ContainerService containerService,
+      WindowService windowService)
     {
       _bus = bus;
       _containerService = containerService;
+      _windowService = windowService;
     }
 
     public CommandResponse Handle(UnmanageWindowCommand command)
@@ -22,23 +27,28 @@ public CommandResponse Handle(UnmanageWindowCommand command)
       var window = command.Window;
 
       // Get container to switch focus to after the window has been removed.
-      var focusTarget = WindowService.GetFocusTargetAfterRemoval(window);
+      var focusedContainer = _containerService.FocusedContainer;
+      var focusTarget = window == focusedContainer
+        ? WindowService.GetFocusTargetAfterRemoval(window)
+        : null;
 
       if (window is IResizable)
         _bus.Invoke(new DetachAndResizeContainerCommand(window));
       else
         _bus.Invoke(new DetachContainerCommand(window));
 
+      _bus.Emit(new WindowUnmanagedEvent(window.Id, window.Handle));
+
+      if (focusTarget is null)
+        return CommandResponse.Ok;
+
       // The OS automatically switches focus to a different window after closing. If
       // there are focusable windows, then set focus *after* the OS sets focus. This will
       // cause focus to briefly flicker to the OS focus target and then to the WM's focus
       // target.
-
       _bus.Invoke(new SetFocusedDescendantCommand(focusTarget));
-      _containerService.PendingFocusContainer = focusTarget;
       _containerService.HasPendingFocusSync = true;
-
-      _bus.Emit(new WindowUnmanagedEvent(window.Id, window.Handle));
+      _windowService.UnmanagedOrMinimizedStopwatch.Restart();
 
       return CommandResponse.Ok;
     }
diff --git a/GlazeWM.Domain/Windows/EventHandlers/WindowFocusedHandler.cs b/GlazeWM.Domain/Windows/EventHandlers/WindowFocusedHandler.cs
index 02b891d74..a15306d5f 100644
--- a/GlazeWM.Domain/Windows/EventHandlers/WindowFocusedHandler.cs
+++ b/GlazeWM.Domain/Windows/EventHandlers/WindowFocusedHandler.cs
@@ -32,36 +32,6 @@ public WindowFocusedHandler(
     public void Handle(WindowFocusedEvent @event)
     {
       var windowHandle = @event.WindowHandle;
-      var pendingFocusContainer = _containerService.PendingFocusContainer;
-
-      // Override the container to set focus to (ie. when changing focus after a window is
-      // closed or hidden).
-      // TODO: This can be simplified a lot. Might also need to handle case where window
-      // is null or not displayed.
-      if (pendingFocusContainer is not null)
-      {
-        // If the container gaining focus is the pending focus container, then reset it.
-        if (pendingFocusContainer is Window && @event.WindowHandle == (pendingFocusContainer as Window).Handle)
-        {
-          _bus.Invoke(new SetFocusedDescendantCommand(pendingFocusContainer));
-          _bus.Emit(new FocusChangedEvent(pendingFocusContainer));
-          _containerService.PendingFocusContainer = null;
-          return;
-        }
-
-        var isDesktopWindow = windowHandle == _windowService.DesktopWindowHandle;
-
-        if (pendingFocusContainer is Workspace && isDesktopWindow)
-        {
-          _bus.Invoke(new SetFocusedDescendantCommand(pendingFocusContainer));
-          _bus.Emit(new FocusChangedEvent(pendingFocusContainer));
-          _containerService.PendingFocusContainer = null;
-          return;
-        }
-
-        _bus.InvokeAsync(new SyncNativeFocusCommand());
-        return;
-      }
 
       var window = _windowService.GetWindows()
         .FirstOrDefault(window => window.Handle == @event.WindowHandle);
@@ -77,6 +47,15 @@ public void Handle(WindowFocusedEvent @event)
       if (window == focusedContainer)
         return;
 
+      var unmanagedStopwatch = _windowService.UnmanagedOrMinimizedStopwatch;
+
+      if (unmanagedStopwatch?.ElapsedMilliseconds < 100)
+      {
+        _logger.LogDebug("Overriding native focus.");
+        _bus.Invoke(new SyncNativeFocusCommand());
+        return;
+      }
+
       // Update the WM's focus state.
       _bus.Invoke(new SetFocusedDescendantCommand(window));
       _bus.Emit(new FocusChangedEvent(window));
diff --git a/GlazeWM.Domain/Windows/EventHandlers/WindowMinimizedHandler.cs b/GlazeWM.Domain/Windows/EventHandlers/WindowMinimizedHandler.cs
index 75e4b02fa..508f78f15 100644
--- a/GlazeWM.Domain/Windows/EventHandlers/WindowMinimizedHandler.cs
+++ b/GlazeWM.Domain/Windows/EventHandlers/WindowMinimizedHandler.cs
@@ -55,14 +55,22 @@ public void Handle(WindowMinimizedEvent @event)
         Id = window.Id
       };
 
-      // Get container to switch focus to after the window has been minimized.
-      var focusTarget = WindowService.GetFocusTargetAfterRemoval(window);
+      // Get container to switch focus to after the window has been minimized. Need to
+      // get focus target prior to calling `ReplaceContainerCommand`.
+      var focusedContainer = _containerService.FocusedContainer;
+      var focusTarget = window == focusedContainer
+        ? WindowService.GetFocusTargetAfterRemoval(window)
+        : null;
 
       _bus.Invoke(new ReplaceContainerCommand(minimizedWindow, window.Parent, window.Index));
 
       // Focus should be reassigned to appropriate container.
-      _bus.Invoke(new SetFocusedDescendantCommand(focusTarget));
-      _containerService.HasPendingFocusSync = true;
+      if (focusTarget is not null)
+      {
+        _bus.Invoke(new SetFocusedDescendantCommand(focusTarget));
+        _containerService.HasPendingFocusSync = true;
+        _windowService.UnmanagedOrMinimizedStopwatch.Restart();
+      }
 
       _containerService.ContainersToRedraw.Add(workspace);
       _bus.Invoke(new RedrawContainersCommand());
diff --git a/GlazeWM.Domain/Windows/WindowService.cs b/GlazeWM.Domain/Windows/WindowService.cs
index 864445533..9bc92567c 100644
--- a/GlazeWM.Domain/Windows/WindowService.cs
+++ b/GlazeWM.Domain/Windows/WindowService.cs
@@ -26,9 +26,10 @@ public class WindowService
     public List<IntPtr> IgnoredHandles { get; set; } = new();
 
     /// <summary>
-    /// Handle to the desktop window.
+    /// Time since a previously focused window was unmanaged or minimized. Used to
+    /// decide whether to override incoming focus events.
     /// </summary>
-    public IntPtr DesktopWindowHandle { get; } = GetDesktopWindowHandle();
+    public Stopwatch UnmanagedOrMinimizedStopwatch { get; } = new();
 
     private readonly ContainerService _containerService;
     private readonly MonitorService _monitorService;
@@ -127,16 +128,6 @@ public static List<IntPtr> GetAllWindowHandles()
       return windowHandles;
     }
 
-    private static IntPtr GetDesktopWindowHandle()
-    {
-      return GetAllWindowHandles().Find(handle =>
-      {
-        var className = GetClassNameOfHandle(handle);
-        var process = GetProcessOfHandle(handle);
-        return className == "Progman" && process.ProcessName == "explorer";
-      });
-    }
-
     public static WindowStylesEx GetWindowStylesEx(IntPtr handle)
     {
       return unchecked((WindowStylesEx)GetWindowLongPtr(handle, GWLEXSTYLE).ToInt64());