diff --git a/quic/core/congestion_control/rtt_stats.h b/quic/core/congestion_control/rtt_stats.h
index 7b58276..997faa4 100644
--- a/quic/core/congestion_control/rtt_stats.h
+++ b/quic/core/congestion_control/rtt_stats.h
@@ -73,7 +73,10 @@
 
   QuicTime::Delta mean_deviation() const { return mean_deviation_; }
 
-  QuicTime::Delta max_ack_delay() const { return max_ack_delay_; }
+  QuicTime::Delta max_ack_delay() const {
+    DCHECK(!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup));
+    return max_ack_delay_;
+  }
 
   QuicTime last_update_time() const { return last_update_time_; }
 
@@ -101,6 +104,7 @@
   QuicTime::Delta initial_rtt_;
   // The maximum ack delay observed over the connection after excluding ack
   // delays that were too large to be included in an RTT measurement.
+  // TODO(ianswett): Remove when deprecating quic_sent_packet_manager_cleanup.
   QuicTime::Delta max_ack_delay_;
   QuicTime last_update_time_;
   // Whether to ignore the peer's max ack delay.
diff --git a/quic/core/congestion_control/rtt_stats_test.cc b/quic/core/congestion_control/rtt_stats_test.cc
index 83cb155..4d259d3 100644
--- a/quic/core/congestion_control/rtt_stats_test.cc
+++ b/quic/core/congestion_control/rtt_stats_test.cc
@@ -35,20 +35,28 @@
                        QuicTime::Zero());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  }
   // Verify that a plausible ack delay increases the max ack delay.
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(400),
                        QuicTime::Delta::FromMilliseconds(100),
                        QuicTime::Zero());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
+              rtt_stats_.max_ack_delay());
+  }
   // Verify that Smoothed RTT includes max ack delay if it's reasonable.
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(350),
                        QuicTime::Delta::FromMilliseconds(50), QuicTime::Zero());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
+              rtt_stats_.max_ack_delay());
+  }
   // Verify that large erroneous ack_delay does not change Smoothed RTT.
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(200),
                        QuicTime::Delta::FromMilliseconds(300),
@@ -56,7 +64,10 @@
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(287500),
             rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
+              rtt_stats_.max_ack_delay());
+  }
 }
 
 TEST_F(RttStatsTest, SmoothedRttIgnoreAckDelay) {
@@ -67,14 +78,18 @@
                        QuicTime::Zero());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  }
   // Verify that a plausible ack delay increases the max ack delay.
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(300),
                        QuicTime::Delta::FromMilliseconds(100),
                        QuicTime::Zero());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300), rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  }
   // Verify that Smoothed RTT includes max ack delay if it's reasonable.
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(300),
                        QuicTime::Delta::FromMilliseconds(50), QuicTime::Zero());
@@ -87,7 +102,9 @@
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(287500),
             rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  }
 }
 
 // Ensure that the potential rounding artifacts in EWMA calculation do not cause
@@ -208,7 +225,9 @@
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.smoothed_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.min_rtt());
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(0), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::FromMilliseconds(0), rtt_stats_.max_ack_delay());
+  }
 
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(300),
                        QuicTime::Delta::FromMilliseconds(100),
@@ -216,14 +235,19 @@
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.smoothed_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.min_rtt());
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
+              rtt_stats_.max_ack_delay());
+  }
 
   // Reset rtt stats on connection migrations.
   rtt_stats_.OnConnectionMigration();
   EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.latest_rtt());
   EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.smoothed_rtt());
   EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.min_rtt());
-  EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  if (!GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.max_ack_delay());
+  }
 }
 
 }  // namespace test
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index fb0e8de..0542edb 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -159,17 +159,29 @@
   if (config.HasClientSentConnectionOption(kMAD1, perspective)) {
     rtt_stats_.set_initial_max_ack_delay(peer_max_ack_delay_);
   }
-  if (config.HasClientSentConnectionOption(kMAD2, perspective)) {
-    min_tlp_timeout_ = QuicTime::Delta::Zero();
-  }
-  if (config.HasClientSentConnectionOption(kMAD3, perspective)) {
-    min_rto_timeout_ = QuicTime::Delta::Zero();
-  }
-  if (config.HasClientSentConnectionOption(kMAD4, perspective)) {
-    ietf_style_tlp_ = true;
-  }
-  if (config.HasClientSentConnectionOption(kMAD5, perspective)) {
-    ietf_style_2x_tlp_ = true;
+  if (GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    QUIC_RELOADABLE_FLAG_COUNT(quic_sent_packet_manager_cleanup);
+    if (config.HasClientSentConnectionOption(kMAD2, perspective)) {
+      // Set the minimum to the alarm granularity.
+      min_tlp_timeout_ = QuicTime::Delta::FromMilliseconds(1);
+    }
+    if (config.HasClientSentConnectionOption(kMAD3, perspective)) {
+      // Set the minimum to the alarm granularity.
+      min_rto_timeout_ = QuicTime::Delta::FromMilliseconds(1);
+    }
+  } else {
+    if (config.HasClientSentConnectionOption(kMAD2, perspective)) {
+      min_tlp_timeout_ = QuicTime::Delta::Zero();
+    }
+    if (config.HasClientSentConnectionOption(kMAD3, perspective)) {
+      min_rto_timeout_ = QuicTime::Delta::Zero();
+    }
+    if (config.HasClientSentConnectionOption(kMAD4, perspective)) {
+      ietf_style_tlp_ = true;
+    }
+    if (config.HasClientSentConnectionOption(kMAD5, perspective)) {
+      ietf_style_2x_tlp_ = true;
+    }
   }
 
   // Configure congestion control.
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 4fce40f..fe34851 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -2259,12 +2259,16 @@
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(100002),
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
 
-  // Send two packets, and the TLP should be 2 us.
+  // Send two packets, and the TLP should be 2 us or 1ms.
+  QuicTime::Delta expected_tlp_delay =
+      GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)
+          ? QuicTime::Delta::FromMilliseconds(1)
+          : QuicTime::Delta::FromMicroseconds(2);
   SendDataPacket(1);
   SendDataPacket(2);
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
 }
 
@@ -2290,16 +2294,23 @@
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(100002),
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
-  // Send two packets, and the TLP should be 2 us.
+  // Send two packets, and the TLP should be 2 us or 1ms.
+  QuicTime::Delta expected_tlp_delay =
+      GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)
+          ? QuicTime::Delta::FromMilliseconds(1)
+          : QuicTime::Delta::FromMicroseconds(2);
   SendDataPacket(1);
   SendDataPacket(2);
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
 }
 
 TEST_P(QuicSentPacketManagerTest, NegotiateIETFTLPFromOptionsAtServer) {
+  if (GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    return;
+  }
   QuicConfig config;
   QuicTagVector options;
 
@@ -2328,6 +2339,9 @@
 }
 
 TEST_P(QuicSentPacketManagerTest, NegotiateIETFTLPFromOptionsAtClient) {
+  if (GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)) {
+    return;
+  }
   QuicConfig client_config;
   QuicTagVector options;
 
@@ -2369,14 +2383,22 @@
   RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   rtt_stats->UpdateRtt(QuicTime::Delta::FromMicroseconds(1),
                        QuicTime::Delta::Zero(), QuicTime::Zero());
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
+  QuicTime::Delta expected_rto_delay =
+      GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)
+          ? QuicTime::Delta::FromMilliseconds(1)
+          : QuicTime::Delta::FromMicroseconds(1);
+  EXPECT_EQ(expected_rto_delay,
             QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
+  EXPECT_EQ(expected_rto_delay,
             QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, 0));
   // The TLP with fewer than 2 packets outstanding includes 1/2 min RTO(0ms).
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  QuicTime::Delta expected_tlp_delay =
+      GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)
+          ? QuicTime::Delta::FromMicroseconds(502)
+          : QuicTime::Delta::FromMicroseconds(2);
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
 }
 
@@ -2394,14 +2416,22 @@
   RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   rtt_stats->UpdateRtt(QuicTime::Delta::FromMicroseconds(1),
                        QuicTime::Delta::Zero(), QuicTime::Zero());
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
+  QuicTime::Delta expected_rto_delay =
+      GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)
+          ? QuicTime::Delta::FromMilliseconds(1)
+          : QuicTime::Delta::FromMicroseconds(1);
+  EXPECT_EQ(expected_rto_delay,
             QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
+  EXPECT_EQ(expected_rto_delay,
             QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, 0));
   // The TLP with fewer than 2 packets outstanding includes 1/2 min RTO(0ms).
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  QuicTime::Delta expected_tlp_delay =
+      GetQuicReloadableFlag(quic_sent_packet_manager_cleanup)
+          ? QuicTime::Delta::FromMicroseconds(502)
+          : QuicTime::Delta::FromMicroseconds(2);
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
-  EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
+  EXPECT_EQ(expected_tlp_delay,
             QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
 }