diff --git a/include/openssl/ssl.h b/include/openssl/ssl.h
index 94a70ae..48ccbbd 100644
--- a/include/openssl/ssl.h
+++ b/include/openssl/ssl.h
@@ -613,7 +613,7 @@
 // This duration overrides the default of 400 milliseconds, which is
 // recommendation of RFC 9147 for real-time protocols.
 OPENSSL_EXPORT void DTLSv1_set_initial_timeout_duration(SSL *ssl,
-                                                        unsigned duration_ms);
+                                                        uint32_t duration_ms);
 
 // DTLSv1_get_timeout queries the running DTLS timers. If there are any in
 // progress, it sets |*out| to the time remaining until the first timer expires
diff --git a/ssl/d1_lib.cc b/ssl/d1_lib.cc
index 55f46b1..c73a102 100644
--- a/ssl/d1_lib.cc
+++ b/ssl/d1_lib.cc
@@ -121,39 +121,79 @@
   ssl->d1 = NULL;
 }
 
+void DTLSTimer::StartMicroseconds(OPENSSL_timeval now, uint64_t microseconds) {
+  uint64_t seconds = microseconds / 1000000;
+  microseconds %= 1000000;
+
+  now.tv_usec += microseconds;
+  if (now.tv_usec >= 1000000) {
+    now.tv_usec -= 1000000;
+    seconds++;
+  }
+
+  if (now.tv_sec > UINT64_MAX - seconds) {
+    Stop();
+    return;
+  }
+  now.tv_sec += seconds;
+  expire_time_ = now;
+}
+
+void DTLSTimer::Stop() { expire_time_ = {0, 0}; }
+
+bool DTLSTimer::IsExpired(OPENSSL_timeval now) const {
+  return MicrosecondsRemaining(now) == 0;
+}
+
+bool DTLSTimer::IsSet() const {
+  return expire_time_.tv_sec != 0 || expire_time_.tv_usec != 0;
+}
+
+uint64_t DTLSTimer::MicrosecondsRemaining(OPENSSL_timeval now) const {
+  if (!IsSet()) {
+    return kNever;
+  }
+
+  if (now.tv_sec > expire_time_.tv_sec ||
+      (now.tv_sec == expire_time_.tv_sec &&
+       now.tv_usec >= expire_time_.tv_usec)) {
+    return 0;
+  }
+
+  uint64_t sec = expire_time_.tv_sec - now.tv_sec;
+  uint32_t usec;
+  if (expire_time_.tv_usec >= now.tv_usec) {
+    usec = expire_time_.tv_usec - now.tv_usec;
+  } else {
+    sec--;
+    usec = expire_time_.tv_usec + 1000000 - now.tv_usec;
+  }
+
+  // If remaining time is less than 15 ms, return 0 to prevent issues because of
+  // small divergences with socket timeouts.
+  if (sec == 0 && usec < 15000) {
+    return 0;
+  }
+
+  if (sec > UINT64_MAX / 1000000) {
+    return kNever;
+  }
+  sec *= 1000000;
+  if (sec > UINT64_MAX - usec) {
+    return kNever;
+  }
+  return sec + usec;
+}
+
 void dtls1_start_timer(SSL *ssl) {
   // If timer is not set, initialize duration.
-  if (ssl->d1->next_timeout.tv_sec == 0 && ssl->d1->next_timeout.tv_usec == 0) {
+  if (!ssl->d1->retransmit_timer.IsSet()) {
     ssl->d1->timeout_duration_ms = ssl->initial_timeout_duration_ms;
   }
 
-  // Set timeout to current time
-  ssl->d1->next_timeout = ssl_ctx_get_current_time(ssl->ctx.get());
-
-  // Add duration to current time
-  ssl->d1->next_timeout.tv_sec += ssl->d1->timeout_duration_ms / 1000;
-  ssl->d1->next_timeout.tv_usec += (ssl->d1->timeout_duration_ms % 1000) * 1000;
-  if (ssl->d1->next_timeout.tv_usec >= 1000000) {
-    ssl->d1->next_timeout.tv_sec++;
-    ssl->d1->next_timeout.tv_usec -= 1000000;
-  }
-}
-
-bool dtls1_is_timer_expired(SSL *ssl) {
-  struct timeval timeleft;
-
-  // Get time left until timeout, return false if no timer running
-  if (!DTLSv1_get_timeout(ssl, &timeleft)) {
-    return false;
-  }
-
-  // Return false if timer is not expired yet
-  if (timeleft.tv_sec > 0 || timeleft.tv_usec > 0) {
-    return false;
-  }
-
-  // Timer expired, so return true
-  return true;
+  OPENSSL_timeval now = ssl_ctx_get_current_time(ssl->ctx.get());
+  ssl->d1->retransmit_timer.StartMicroseconds(
+      now, uint64_t{ssl->d1->timeout_duration_ms} * 1000);
 }
 
 static void dtls1_double_timeout(SSL *ssl) {
@@ -165,7 +205,7 @@
 
 void dtls1_stop_timer(SSL *ssl) {
   ssl->d1->num_timeouts = 0;
-  ssl->d1->next_timeout = {0, 0};
+  ssl->d1->retransmit_timer.Stop();
   ssl->d1->timeout_duration_ms = ssl->initial_timeout_duration_ms;
 }
 
@@ -195,7 +235,7 @@
 
 using namespace bssl;
 
-void DTLSv1_set_initial_timeout_duration(SSL *ssl, unsigned int duration_ms) {
+void DTLSv1_set_initial_timeout_duration(SSL *ssl, uint32_t duration_ms) {
   ssl->initial_timeout_duration_ms = duration_ms;
 }
 
@@ -204,46 +244,25 @@
     return 0;
   }
 
-  // If no timeout is set, just return 0.
-  if (ssl->d1->next_timeout.tv_sec == 0 && ssl->d1->next_timeout.tv_usec == 0) {
-    return 0;
+  OPENSSL_timeval now = ssl_ctx_get_current_time(ssl->ctx.get());
+  uint64_t remaining_usec =
+      ssl->d1->retransmit_timer.MicrosecondsRemaining(now);
+  if (remaining_usec == DTLSTimer::kNever) {
+    return 0;  // No timeout is set.
   }
 
-  OPENSSL_timeval timenow = ssl_ctx_get_current_time(ssl->ctx.get());
+  uint64_t remaining_sec = remaining_usec / 1000000;
+  remaining_usec %= 1000000;
 
-  // If timer already expired, set remaining time to 0.
-  if (ssl->d1->next_timeout.tv_sec < timenow.tv_sec ||
-      (ssl->d1->next_timeout.tv_sec == timenow.tv_sec &&
-       ssl->d1->next_timeout.tv_usec <= timenow.tv_usec)) {
-    OPENSSL_memset(out, 0, sizeof(*out));
-    return 1;
-  }
-
-  // Calculate time left until timer expires.
-  OPENSSL_timeval ret = ssl->d1->next_timeout;
-  ret.tv_sec -= timenow.tv_sec;
-  if (ret.tv_usec >= timenow.tv_usec) {
-    ret.tv_usec -= timenow.tv_usec;
+  // |timeval| uses |time_t|, which may be 32-bit.
+  const auto kTvSecMax = std::numeric_limits<decltype(out->tv_sec)>::max();
+  if (remaining_sec > static_cast<uint64_t>(kTvSecMax)) {
+    out->tv_sec = kTvSecMax;  // Saturate the output.
+    out->tv_usec = 999999;
   } else {
-    ret.tv_usec = 1000000 + ret.tv_usec - timenow.tv_usec;
-    ret.tv_sec--;
+    out->tv_sec = static_cast<decltype(out->tv_sec)>(remaining_sec);
   }
-
-  // If remaining time is less than 15 ms, set it to 0 to prevent issues
-  // because of small divergences with socket timeouts.
-  if (ret.tv_sec == 0 && ret.tv_usec < 15000) {
-    ret = {0, 0};
-  }
-
-  // Clamp the result in case of overflow.
-  if (ret.tv_sec > INT_MAX) {
-    assert(0);
-    out->tv_sec = INT_MAX;
-  } else {
-    out->tv_sec = ret.tv_sec;
-  }
-
-  out->tv_usec = ret.tv_usec;
+  out->tv_usec = remaining_usec;
   return 1;
 }
 
@@ -256,7 +275,8 @@
   }
 
   // If no timer is expired, don't do anything.
-  if (!dtls1_is_timer_expired(ssl)) {
+  OPENSSL_timeval now = ssl_ctx_get_current_time(ssl->ctx.get());
+  if (!ssl->d1->retransmit_timer.IsExpired(now)) {
     return 0;
   }
 
diff --git a/ssl/internal.h b/ssl/internal.h
index f559b54..8dcc097 100644
--- a/ssl/internal.h
+++ b/ssl/internal.h
@@ -3463,6 +3463,41 @@
   uint32_t tv_usec;
 };
 
+struct DTLSTimer {
+ public:
+  static constexpr uint64_t kNever = UINT64_MAX;
+
+  // StartMicroseconds schedules the timer to expire the specified number of
+  // microseconds from |now|.
+  void StartMicroseconds(OPENSSL_timeval now, uint64_t microseconds);
+
+  // Stop disables the timer.
+  void Stop();
+
+  // IsExpired returns true if the timer was set and is expired at time |now|.
+  bool IsExpired(OPENSSL_timeval now) const;
+
+  // IsSet returns true if the timer is scheduled or expired, and false if it is
+  // stopped.
+  bool IsSet() const;
+
+  // MicrosecondsRemaining returns the time remaining, in microseconds, at
+  // |now|, or |kNever| if the timer is unset.
+  uint64_t MicrosecondsRemaining(OPENSSL_timeval now) const;
+
+ private:
+  // expire_time_ is the time when the timer expires, or zero if the timer is
+  // unset.
+  //
+  // TODO(crbug.com/366284846): This is an extremely inconvenient time
+  // representation. Switch libssl to something like a 64-bit count of
+  // microseconds. While it's decidedly past 1970 now, zero is a less obviously
+  // sound distinguished value for the monotonic clock, so maybe we should use a
+  // different distinguished time, like |INT64_MAX| in the microseconds
+  // representation.
+  OPENSSL_timeval expire_time_ = {0, 0};
+};
+
 // DTLS_MAX_EXTRA_WRITE_EPOCHS is the maximum number of additional write epochs
 // that DTLS may need to retain.
 //
@@ -3574,12 +3609,12 @@
   // the last time it was reset.
   unsigned num_timeouts = 0;
 
-  // Indicates when the last handshake msg or heartbeat sent will
-  // timeout.
-  struct OPENSSL_timeval next_timeout = {0, 0};
+  // retransmit_timer tracks when to schedule the next DTLS retransmit if we do
+  // not hear from the peer.
+  DTLSTimer retransmit_timer;
 
   // timeout_duration_ms is the timeout duration in milliseconds.
-  unsigned timeout_duration_ms = 0;
+  uint32_t timeout_duration_ms = 0;
 };
 
 // An ALPSConfig is a pair of ALPN protocol and settings value to use with ALPS.
@@ -3944,7 +3979,6 @@
 
 void dtls1_start_timer(SSL *ssl);
 void dtls1_stop_timer(SSL *ssl);
-bool dtls1_is_timer_expired(SSL *ssl);
 unsigned int dtls1_min_mtu(void);
 
 bool dtls1_new(SSL *ssl);
@@ -4440,7 +4474,7 @@
   // initial_timeout_duration_ms is the default DTLS timeout duration in
   // milliseconds. It's used to initialize the timer any time it's restarted. We
   // default to RFC 9147's recommendation for real-time applications, 400ms.
-  unsigned initial_timeout_duration_ms = 400;
+  uint32_t initial_timeout_duration_ms = 400;
 
   // session is the configured session to be offered by the client. This session
   // is immutable.