-if time.monotonic() > end_time:
+remaining_time = end_time - time.monotonic()
+if remaining_time <= 0:
     break
-time.sleep(self._poll)
+time.sleep(min(self._poll, remaining_time))

 def until(self, method: Callable[[D], Union[Literal[False], T]], message: str = "") -> T:
     """Calls the method provided with the driver as an argument until the \
     return value does not evaluate to ``False``.
 
     :param method: callable(WebDriver)
     :param message: optional message for :exc:`TimeoutException`
     :returns: the result of the last call to `method`
     :raises: :exc:`selenium.common.exceptions.TimeoutException` if timeout occurs
     """
     screen = None
     stacktrace = None
 
-    end_time = time.monotonic() + self._timeout
-    while True:
-        value = method(self._driver)
-        if value:
-            return value
-        except self._ignored_exceptions as exc:
-            screen = getattr(exc, "screen", None)
-            stacktrace = getattr(exc, "stacktrace", None)
-        if time.monotonic() > end_time:
-            break
-        time.sleep(self._poll)
+    with contextlib.suppress(self._ignored_exceptions):
+        end_time = time.monotonic() + self._timeout
+        while time.monotonic() <= end_time:
+            try:
+                value = method(self._driver)
+                if value:
+                    return value
+            except self._ignored_exceptions as exc:
+                screen = getattr(exc, "screen", None)
+                stacktrace = getattr(exc, "stacktrace", None)
+            time.sleep(self._poll)
     raise TimeoutException(message, screen, stacktrace)

 while True:
+    time.sleep(self._poll)
     value = method(self._driver)
     if value:
         return value
     except self._ignored_exceptions as exc:
         screen = getattr(exc, "screen", None)
         stacktrace = getattr(exc, "stacktrace", None)
     if time.monotonic() > end_time:
         break
-    time.sleep(self._poll)