diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 6d6c93a..4cb08c5 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -2393,17 +2393,6 @@
          QuicVersionUsesCryptoFrames(transport_version()))
       << ENDPOINT
       << "Handshake in STREAM frames should not check ShouldGeneratePacket";
-  // We should serialize handshake packets immediately to ensure that they
-  // end up sent at the right encryption level.
-  if (!move_amplification_limit_ && handshake == IS_HANDSHAKE) {
-    if (LimitedByAmplificationFactor()) {
-      // Server is constrained by the amplification restriction.
-      QUIC_DVLOG(1) << ENDPOINT << "Constrained by amplification restriction";
-      return false;
-    }
-    return true;
-  }
-
   return CanWrite(retransmittable);
 }
 
@@ -2440,9 +2429,8 @@
     return false;
   }
 
-  if (move_amplification_limit_ && LimitedByAmplificationFactor()) {
+  if (LimitedByAmplificationFactor()) {
     // Server is constrained by the amplification restriction.
-    QUIC_RELOADABLE_FLAG_COUNT(quic_move_amplification_limit);
     QUIC_CODE_COUNT(quic_throttled_by_amplification_limit);
     QUIC_DVLOG(1) << ENDPOINT << "Constrained by amplification restriction";
     return false;
@@ -4277,9 +4265,7 @@
     const bool flushed = packet_creator_.FlushAckFrame(frames);
     if (!flushed) {
       // Connection is write blocked.
-      QUIC_BUG_IF(
-          !writer_->IsWriteBlocked() &&
-          (!move_amplification_limit_ || !LimitedByAmplificationFactor()))
+      QUIC_BUG_IF(!writer_->IsWriteBlocked() && !LimitedByAmplificationFactor())
           << "Writer not blocked and not throttled by amplification factor, "
              "but ACK not flushed for packet space:"
           << i;
@@ -4479,7 +4465,7 @@
 bool QuicConnection::LimitedByAmplificationFactor() const {
   return EnforceAntiAmplificationLimit() &&
          bytes_sent_before_address_validation_ >=
-             anti_amplification_factor_ *
+             GetQuicFlag(FLAGS_quic_anti_amplification_factor) *
                  bytes_received_before_address_validation_;
 }
 
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 573cc07..dc2a00f 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -979,10 +979,6 @@
   // Returns true if ack_alarm_ is set.
   bool HasPendingAcks() const;
 
-  size_t anti_amplification_factor() const {
-    return anti_amplification_factor_;
-  }
-
   void OnUserAgentIdKnown() { sent_packet_manager_.OnUserAgentIdKnown(); }
 
   // Enables Legacy Version Encapsulation using |server_name| as SNI.
@@ -1670,19 +1666,6 @@
   // True if this connection supports handshake done frame.
   bool support_handshake_done_;
 
-  const bool move_amplification_limit_ =
-      GetQuicReloadableFlag(quic_move_amplification_limit);
-
-  // TODO(fayang): Change the default value of quic_anti_amplification_factor to
-  // 5 when deprecating quic_move_amplification_limit.
-  // TODO(b/153892665): Change the default value of
-  // quic_anti_amplification_factor back to 3 when cert compression is
-  // supported.
-  const size_t anti_amplification_factor_ =
-      move_amplification_limit_
-          ? 5
-          : GetQuicFlag(FLAGS_quic_anti_amplification_factor);
-
   const bool default_enable_5rto_blackhole_detection_ =
       GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2);
 
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index b9f1fc5..f1ae21d 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -7053,8 +7053,7 @@
   ProcessPacket(1);
   BlockOnNextWrite();
   writer_->set_is_write_blocked_data_buffered(true);
-  if (GetQuicReloadableFlag(quic_move_amplification_limit) &&
-      QuicVersionUsesCryptoFrames(connection_.transport_version())) {
+  if (QuicVersionUsesCryptoFrames(connection_.transport_version())) {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   } else {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
@@ -7064,8 +7063,7 @@
   EXPECT_FALSE(connection_.HasQueuedData());
   connection_.SendCryptoDataWithString("bar", 3);
   EXPECT_TRUE(writer_->IsWriteBlocked());
-  if (GetQuicReloadableFlag(quic_move_amplification_limit) &&
-      QuicVersionUsesCryptoFrames(connection_.transport_version())) {
+  if (QuicVersionUsesCryptoFrames(connection_.transport_version())) {
     // CRYPTO frames are not flushed when writer is blocked.
     EXPECT_FALSE(connection_.HasQueuedData());
   } else {
@@ -10099,17 +10097,15 @@
   // Verify no data can be sent at the beginning because bytes received is 0.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   connection_.SendCryptoDataWithString("foo", 0);
-  if (GetQuicReloadableFlag(quic_move_amplification_limit)) {
-    EXPECT_FALSE(connection_.CanWrite(HAS_RETRANSMITTABLE_DATA));
-    EXPECT_FALSE(connection_.CanWrite(NO_RETRANSMITTABLE_DATA));
-  }
+  EXPECT_FALSE(connection_.CanWrite(HAS_RETRANSMITTABLE_DATA));
+  EXPECT_FALSE(connection_.CanWrite(NO_RETRANSMITTABLE_DATA));
   EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
 
   // Receives packet 1.
   ProcessCryptoPacketAtLevel(1, ENCRYPTION_INITIAL);
 
   const size_t anti_amplification_factor =
-      connection_.anti_amplification_factor();
+      GetQuicFlag(FLAGS_quic_anti_amplification_factor);
   // Verify now packets can be sent.
   for (size_t i = 0; i < anti_amplification_factor; ++i) {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
@@ -10145,8 +10141,7 @@
 }
 
 TEST_P(QuicConnectionTest, AckPendingWithAmplificationLimited) {
-  if (!connection_.version().SupportsAntiAmplificationLimit() ||
-      !GetQuicReloadableFlag(quic_move_amplification_limit)) {
+  if (!connection_.version().SupportsAntiAmplificationLimit()) {
     return;
   }
   EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(AnyNumber());