diff --git a/patroni/watchdog/base.py b/patroni/watchdog/base.py
index be731b98d3..5599226dbf 100644
--- a/patroni/watchdog/base.py
+++ b/patroni/watchdog/base.py
@@ -92,6 +92,7 @@ def __init__(self, config: Config) -> None:
         self.active_config: WatchdogConfig = self.config
         self.lock = RLock()
         self.active = False
+        self._impl_pending = False
 
         if self.config.mode == MODE_OFF:
             self.impl = NullWatchdog()
@@ -110,12 +111,15 @@ def reload_config(self, config: Config) -> None:
                 self._disable()
             self.active_config = self.config
             self.impl = NullWatchdog()
+            self._impl_pending = False
         # If watchdog is not active we can apply config immediately to show any warnings early. Otherwise we need to
         # delay until next time a keepalive is sent so timeout matches up with leader key update.
         if not self.active:
-            if self.config.driver != self.active_config.driver or \
-               self.config.driver_config != self.active_config.driver_config:
+            if self._impl_pending or self.config.mode != self.active_config.mode or \
+                    self.config.driver != self.active_config.driver or \
+                    self.config.driver_config != self.active_config.driver_config:
                 self.impl = self.config.get_impl()
+                self._impl_pending = False
             self.active_config = self.config
 
     @synchronized
@@ -126,7 +130,16 @@ def activate(self) -> bool:
         :returns False if a safe watchdog could not be configured, but is required.
         """
         self.active = True
-        return self._activate()
+        # A configuration change might have been deferred to a keepalive that was never sent
+        if not self.impl.is_running and (self._impl_pending or self.config.mode != self.active_config.mode):
+            self.impl = self.config.get_impl()
+            self._impl_pending = False
+        if self._activate():
+            return True
+        # The HA loop gives up the leader key, so keepalive() won't apply configuration changes anymore. Unless a
+        # running watchdog has to be disabled on demotion, reload_config() must apply them, or the node stays unhealthy.
+        self.active = self.impl.is_running
+        return False
 
     def _activate(self) -> bool:
         self.active_config = self.config
@@ -135,6 +148,8 @@ def _activate(self) -> bool:
             logger.warning('Watchdog not supported because leader TTL %s is less than 2x loop_wait %s',
                            self.config.ttl, self.config.loop_wait)
             self.impl = NullWatchdog()
+            # Reacquire the configured device once a configuration change fixes the timing.
+            self._impl_pending = True
 
         try:
             self.impl.open()
@@ -211,8 +226,9 @@ def keepalive(self) -> None:
                 self.impl.keepalive()
             # In case there are any pending configuration changes apply them now.
             if self.active and self.config != self.active_config:
-                if self.config.mode != MODE_OFF and self.active_config.mode == MODE_OFF:
+                if not self.impl.is_running and (self._impl_pending or self.config.mode != self.active_config.mode):
                     self.impl = self.config.get_impl()
+                    self._impl_pending = False
                     self._activate()
                 if self.config.driver != self.active_config.driver \
                    or self.config.driver_config != self.active_config.driver_config:
diff --git a/tests/test_watchdog.py b/tests/test_watchdog.py
index 62dc6ccbf3..0eb2c717ad 100644
--- a/tests/test_watchdog.py
+++ b/tests/test_watchdog.py
@@ -164,9 +164,12 @@ def test_config_reload(self):
         self.assertFalse(watchdog.is_healthy)
 
         self.assertFalse(watchdog.activate())
+        # the HA loop gives up the leader key, so the next activation picks up the reloaded configuration
         watchdog.reload_config({'ttl': 30, 'loop_wait': 15, 'watchdog': {'mode': 'required'}})
         self.assertFalse(watchdog.is_running)
         watchdog.keepalive()
+        self.assertFalse(watchdog.is_running)
+        self.assertTrue(watchdog.activate())
         self.assertTrue(watchdog.is_running)
 
         watchdog.reload_config({'ttl': 60, 'loop_wait': 15, 'watchdog': {'mode': 'required'}})
@@ -179,6 +182,62 @@ def test_config_reload(self):
         self.assertTrue(watchdog.is_running)
         self.assertEqual(watchdog.config.timeout, 60 // 2)
 
+    @patch('platform.system', Mock(return_value='Linux'))
+    @patch.object(LinuxWatchdogDevice, 'is_healthy', PropertyMock(return_value=True))
+    def test_reacquire_after_unsafe_timing(self):
+        config = {'ttl': 20, 'loop_wait': 10, 'watchdog': {'safety_margin': 12}}
+        for mode in ('automatic', 'required'):
+            with self.subTest(mode=mode):
+                config['watchdog']['mode'] = mode
+                watchdog = Watchdog(config)
+                self.assertEqual(watchdog.activate(), mode == 'automatic')
+                self.assertFalse(watchdog.is_running)
+                self.assertEqual(watchdog.is_healthy, mode == 'automatic')
+                # automatic mode keeps the leader key, required mode gives it up
+                watchdog.reload_config(dict(config, ttl=30))
+                if mode == 'automatic':
+                    watchdog.keepalive()
+                else:
+                    self.assertTrue(watchdog.is_healthy)
+                    self.assertTrue(watchdog.activate())
+                self.assertTrue(watchdog.is_running)
+                watchdog.disable()
+
+    @patch('platform.system', Mock(return_value='Linux'))
+    def test_mode_off_after_unsafe_timing(self):
+        config = {'ttl': 20, 'loop_wait': 10, 'watchdog': {'mode': 'automatic', 'safety_margin': 12}}
+        for leader in (True, False):
+            with self.subTest(leader=leader):
+                watchdog = Watchdog(config)
+                self.assertTrue(watchdog.activate())
+                if not leader:
+                    watchdog.disable()
+                # the device must not be acquired anymore once the watchdog is turned off
+                watchdog.reload_config({'ttl': 30, 'loop_wait': 10, 'watchdog': {'mode': 'off'}})
+                self.assertTrue(watchdog.activate())
+                self.assertFalse(watchdog.is_running)
+
+    @patch('platform.system', Mock(return_value='Linux'))
+    @patch.object(LinuxWatchdogDevice, 'is_healthy', PropertyMock(return_value=True))
+    def test_reacquire_after_mode_change(self):
+        watchdog = Watchdog({'ttl': 30, 'loop_wait': 10, 'watchdog': {'mode': 'off'}})
+        self.assertTrue(watchdog.activate())
+        watchdog.disable()
+        watchdog.reload_config({'ttl': 30, 'loop_wait': 10, 'watchdog': {'mode': 'required'}})
+        self.assertTrue(watchdog.is_healthy)
+        self.assertTrue(watchdog.activate())
+        self.assertTrue(watchdog.is_running)
+        watchdog.disable()
+
+        # the change was deferred to a keepalive, but the watchdog was disabled first
+        watchdog.reload_config({'ttl': 30, 'loop_wait': 10, 'watchdog': {'mode': 'off'}})
+        self.assertTrue(watchdog.activate())
+        watchdog.reload_config({'ttl': 30, 'loop_wait': 10, 'watchdog': {'mode': 'required'}})
+        watchdog.disable()
+        self.assertTrue(watchdog.activate())
+        self.assertTrue(watchdog.is_running)
+        watchdog.disable()
+
 
 class TestNullWatchdog(unittest.TestCase):
 
