diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 3be4286..fe1a5ee 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -115,10 +115,8 @@
 
 namespace {
 
-// Salt from https://tools.ietf.org/html/draft-ietf-quic-tls-25#section-5.2
-// and https://tools.ietf.org/html/draft-ietf-quic-tls-27#section-5.2
-// and https://tools.ietf.org/html/draft-ietf-quic-tls-28#section-5.2
-const uint8_t kDraft25InitialSalt[] = {0xc3, 0xee, 0xf7, 0x12, 0xc7, 0x2e, 0xbb,
+// Salt from https://tools.ietf.org/html/draft-ietf-quic-tls-27#section-5.2
+const uint8_t kDraft27InitialSalt[] = {0xc3, 0xee, 0xf7, 0x12, 0xc7, 0x2e, 0xbb,
                                        0x5a, 0x11, 0xa7, 0xd2, 0x43, 0x2b, 0xb4,
                                        0x63, 0x65, 0xbe, 0xf9, 0xf5, 0x02};
 
@@ -145,16 +143,15 @@
 
 const uint8_t* InitialSaltForVersion(const ParsedQuicVersion& version,
                                      size_t* out_len) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync with initial encryption salts");
   if (version == ParsedQuicVersion::Draft29()) {
     *out_len = QUICHE_ARRAYSIZE(kDraft29InitialSalt);
     return kDraft29InitialSalt;
   } else if (version == ParsedQuicVersion::Draft27() ||
-             version == ParsedQuicVersion::Draft25() ||
              version == ParsedQuicVersion::ReservedForNegotiation()) {
-    *out_len = QUICHE_ARRAYSIZE(kDraft25InitialSalt);
-    return kDraft25InitialSalt;
+    *out_len = QUICHE_ARRAYSIZE(kDraft27InitialSalt);
+    return kDraft27InitialSalt;
   } else if (version == ParsedQuicVersion::T051()) {
     *out_len = QUICHE_ARRAYSIZE(kT051Salt);
     return kT051Salt;
@@ -166,20 +163,18 @@
     return kQ050Salt;
   }
   QUIC_BUG << "No initial obfuscation salt for version " << version;
-  *out_len = QUICHE_ARRAYSIZE(kDraft25InitialSalt);
-  return kDraft25InitialSalt;
+  *out_len = QUICHE_ARRAYSIZE(kDraft27InitialSalt);
+  return kDraft27InitialSalt;
 }
 
 const char kPreSharedKeyLabel[] = "QUIC PSK";
 
 // Retry Integrity Protection Keys and Nonces.
-// https://tools.ietf.org/html/draft-ietf-quic-tls-25#section-5.8
 // https://tools.ietf.org/html/draft-ietf-quic-tls-27#section-5.8
-// https://tools.ietf.org/html/draft-ietf-quic-tls-28#section-5.8
-const uint8_t kDraft25RetryIntegrityKey[] = {0x4d, 0x32, 0xec, 0xdb, 0x2a, 0x21,
+const uint8_t kDraft27RetryIntegrityKey[] = {0x4d, 0x32, 0xec, 0xdb, 0x2a, 0x21,
                                              0x33, 0xc8, 0x41, 0xe4, 0x04, 0x3d,
                                              0xf2, 0x7d, 0x44, 0x30};
-const uint8_t kDraft25RetryIntegrityNonce[] = {
+const uint8_t kDraft27RetryIntegrityNonce[] = {
     0x4d, 0x16, 0x11, 0xd0, 0x55, 0x13, 0xa5, 0x52, 0xc5, 0x87, 0xd5, 0x75};
 
 // https://tools.ietf.org/html/draft-ietf-quic-tls-29#section-5.8
@@ -207,7 +202,7 @@
 bool RetryIntegrityKeysForVersion(const ParsedQuicVersion& version,
                                   quiche::QuicheStringPiece* key,
                                   quiche::QuicheStringPiece* nonce) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync with retry integrity keys");
   if (!version.HasRetryIntegrityTag()) {
     QUIC_BUG << "Attempted to get retry integrity keys for invalid version "
@@ -221,14 +216,13 @@
         reinterpret_cast<const char*>(kDraft29RetryIntegrityNonce),
         QUICHE_ARRAYSIZE(kDraft29RetryIntegrityNonce));
     return true;
-  } else if (version == ParsedQuicVersion::Draft25() ||
-             version == ParsedQuicVersion::Draft27()) {
+  } else if (version == ParsedQuicVersion::Draft27()) {
     *key = quiche::QuicheStringPiece(
-        reinterpret_cast<const char*>(kDraft25RetryIntegrityKey),
-        QUICHE_ARRAYSIZE(kDraft25RetryIntegrityKey));
+        reinterpret_cast<const char*>(kDraft27RetryIntegrityKey),
+        QUICHE_ARRAYSIZE(kDraft27RetryIntegrityKey));
     *nonce = quiche::QuicheStringPiece(
-        reinterpret_cast<const char*>(kDraft25RetryIntegrityNonce),
-        QUICHE_ARRAYSIZE(kDraft25RetryIntegrityNonce));
+        reinterpret_cast<const char*>(kDraft27RetryIntegrityNonce),
+        QUICHE_ARRAYSIZE(kDraft27RetryIntegrityNonce));
     return true;
   } else if (version == ParsedQuicVersion::T051()) {
     *key = quiche::QuicheStringPiece(
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index c547d19..49c5c4d 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -10517,10 +10517,6 @@
   }
 
   // These values come from draft-ietf-quic-tls Appendix A.4.
-  char retry_packet25[] = {
-      0xff, 0xff, 0x00, 0x00, 0x19, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
-      0x42, 0x62, 0xb5, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x1e, 0x5e, 0xc5, 0xb0,
-      0x14, 0xcb, 0xb1, 0xf0, 0xfd, 0x93, 0xdf, 0x40, 0x48, 0xc4, 0x46, 0xa6};
   char retry_packet27[] = {
       0xff, 0xff, 0x00, 0x00, 0x1b, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
       0x42, 0x62, 0xb5, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0xa5, 0x23, 0xcb, 0x5b,
@@ -10538,9 +10534,6 @@
   } else if (version() == ParsedQuicVersion::Draft27()) {
     retry_packet = retry_packet27;
     retry_packet_length = QUICHE_ARRAYSIZE(retry_packet27);
-  } else if (version() == ParsedQuicVersion::Draft25()) {
-    retry_packet = retry_packet25;
-    retry_packet_length = QUICHE_ARRAYSIZE(retry_packet25);
   } else {
     // TODO(dschinazi) generate retry packets for all versions once we have
     // server-side support for generating these programmatically.
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 8d06ce5..1fa601f 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -1084,78 +1084,129 @@
 }
 
 TEST_P(QuicDispatcherTestOneVersion,
-       RejectDeprecatedVersionsWithVersionNegotiation) {
-  static_assert(quic::SupportedVersions().size() == 8u,
-                "Please add deprecated versions to this test");
+       RejectDeprecatedVersionDraft28WithVersionNegotiation) {
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   CreateTimeWaitListManager();
-
-  {
-    char packet49[kMinPacketSizeForVersionNegotiation] = {
-        0xC0, 'Q', '0', '4', '9', /*connection ID length byte*/ 0x50};
-    QuicReceivedPacket received_packet49(
-        packet49, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
-        .Times(1);
-    dispatcher_->ProcessPacket(server_address_, client_address,
-                               received_packet49);
-  }
-
-  {
-    char packet48[kMinPacketSizeForVersionNegotiation] = {
-        0xC0, 'Q', '0', '4', '8', /*connection ID length byte*/ 0x50};
-    QuicReceivedPacket received_packet48(
-        packet48, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
-        .Times(1);
-    dispatcher_->ProcessPacket(server_address_, client_address,
-                               received_packet48);
-  }
-
-  {
-    char packet47[kMinPacketSizeForVersionNegotiation] = {
-        0xC0, 'Q', '0', '4', '7', /*connection ID length byte*/ 0x50};
-    QuicReceivedPacket received_packet47(
-        packet47, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
-        .Times(1);
-    dispatcher_->ProcessPacket(server_address_, client_address,
-                               received_packet47);
-  }
-
-  {
-    char packet45[kMinPacketSizeForVersionNegotiation] = {
-        0xC0, 'Q', '0', '4', '5', /*connection ID length byte*/ 0x50};
-    QuicReceivedPacket received_packet45(
-        packet45, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
-        .Times(1);
-    dispatcher_->ProcessPacket(server_address_, client_address,
-                               received_packet45);
-  }
-
-  {
-    char packet44[kMinPacketSizeForVersionNegotiation] = {
-        0xFF, 'Q', '0', '4', '4', /*connection ID length byte*/ 0x50};
-    QuicReceivedPacket received_packet44(
-        packet44, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
-    EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(*time_wait_list_manager_,
-                SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
-        .Times(1);
-    dispatcher_->ProcessPacket(server_address_, client_address,
-                               received_packet44);
-  }
+  char packet[kMinPacketSizeForVersionNegotiation] = {
+      0xC0, 0xFF, 0x00, 0x00, 28, /*destination connection ID length*/ 0x08};
+  QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+                                     QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(
+      *time_wait_list_manager_,
+      SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
+                                   /*use_length_prefix=*/true, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
 }
 
+TEST_P(QuicDispatcherTestOneVersion,
+       RejectDeprecatedVersionDraft25WithVersionNegotiation) {
+  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  CreateTimeWaitListManager();
+  char packet[kMinPacketSizeForVersionNegotiation] = {
+      0xC0, 0xFF, 0x00, 0x00, 25, /*destination connection ID length*/ 0x08};
+  QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+                                     QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(
+      *time_wait_list_manager_,
+      SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
+                                   /*use_length_prefix=*/true, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
+}
+
+TEST_P(QuicDispatcherTestOneVersion,
+       RejectDeprecatedVersionQ049WithVersionNegotiation) {
+  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  CreateTimeWaitListManager();
+  char packet[kMinPacketSizeForVersionNegotiation] = {
+      0xC0, 'Q', '0', '4', '9', /*destination connection ID length*/ 0x08};
+  QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+                                     QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(
+      *time_wait_list_manager_,
+      SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
+                                   /*use_length_prefix=*/true, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
+}
+
+TEST_P(QuicDispatcherTestOneVersion,
+       RejectDeprecatedVersionQ048WithVersionNegotiation) {
+  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  CreateTimeWaitListManager();
+  char packet[kMinPacketSizeForVersionNegotiation] = {
+      0xC0, 'Q', '0', '4', '8', /*connection ID length byte*/ 0x50};
+  QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+                                     QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(
+      *time_wait_list_manager_,
+      SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
+                                   /*use_length_prefix=*/false, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
+}
+
+TEST_P(QuicDispatcherTestOneVersion,
+       RejectDeprecatedVersionQ047WithVersionNegotiation) {
+  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  CreateTimeWaitListManager();
+  char packet[kMinPacketSizeForVersionNegotiation] = {
+      0xC0, 'Q', '0', '4', '7', /*connection ID length byte*/ 0x50};
+  QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+                                     QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(
+      *time_wait_list_manager_,
+      SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
+                                   /*use_length_prefix=*/false, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
+}
+
+TEST_P(QuicDispatcherTestOneVersion,
+       RejectDeprecatedVersionQ045WithVersionNegotiation) {
+  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  CreateTimeWaitListManager();
+  char packet[kMinPacketSizeForVersionNegotiation] = {
+      0xC0, 'Q', '0', '4', '5', /*connection ID length byte*/ 0x50};
+  QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+                                     QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(
+      *time_wait_list_manager_,
+      SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
+                                   /*use_length_prefix=*/false, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
+}
+
+TEST_P(QuicDispatcherTestOneVersion,
+       RejectDeprecatedVersionQ044WithVersionNegotiation) {
+  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  CreateTimeWaitListManager();
+  char packet44[kMinPacketSizeForVersionNegotiation] = {
+      0xFF, 'Q', '0', '4', '4', /*connection ID length byte*/ 0x50};
+  QuicReceivedPacket received_packet44(
+      packet44, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(
+      *time_wait_list_manager_,
+      SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
+                                   /*use_length_prefix=*/false, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address,
+                             received_packet44);
+}
+
+static_assert(quic::SupportedVersions().size() == 7u,
+              "Please add new RejectDeprecatedVersion tests above this assert "
+              "when deprecating versions");
+
 TEST_P(QuicDispatcherTestOneVersion, VersionNegotiationProbeOld) {
   SetQuicFlag(FLAGS_quic_prober_uses_length_prefixed_connection_ids, false);
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 57db3c9..52bb9a2 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -19,15 +19,13 @@
           GetQuicReloadableFlag(quic_disable_version_draft_29)),
       disable_version_draft_27_(
           GetQuicReloadableFlag(quic_disable_version_draft_27)),
-      disable_version_draft_25_(
-          GetQuicReloadableFlag(quic_disable_version_draft_25)),
       enable_version_t051_(GetQuicReloadableFlag(quic_enable_version_t051)),
       disable_version_t050_(GetQuicReloadableFlag(quic_disable_version_t050)),
       disable_version_q050_(GetQuicReloadableFlag(quic_disable_version_q050)),
       disable_version_q046_(GetQuicReloadableFlag(quic_disable_version_q046)),
       disable_version_q043_(GetQuicReloadableFlag(quic_disable_version_q043)),
       allowed_supported_versions_(std::move(supported_versions)) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   RefilterSupportedVersions();
 }
@@ -57,14 +55,12 @@
 }
 
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   if (disable_version_draft_29_ !=
           GetQuicReloadableFlag(quic_disable_version_draft_29) ||
       disable_version_draft_27_ !=
           GetQuicReloadableFlag(quic_disable_version_draft_27) ||
-      disable_version_draft_25_ !=
-          GetQuicReloadableFlag(quic_disable_version_draft_25) ||
       enable_version_t051_ != GetQuicReloadableFlag(quic_enable_version_t051) ||
       disable_version_t050_ !=
           GetQuicReloadableFlag(quic_disable_version_t050) ||
@@ -78,8 +74,6 @@
         GetQuicReloadableFlag(quic_disable_version_draft_29);
     disable_version_draft_27_ =
         GetQuicReloadableFlag(quic_disable_version_draft_27);
-    disable_version_draft_25_ =
-        GetQuicReloadableFlag(quic_disable_version_draft_25);
     enable_version_t051_ = GetQuicReloadableFlag(quic_enable_version_t051);
     disable_version_t050_ = GetQuicReloadableFlag(quic_disable_version_t050);
     disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index 9eb69ed..cbf5de1 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -56,8 +56,6 @@
   bool disable_version_draft_29_;
   // quic_disable_version_draft_27 flag
   bool disable_version_draft_27_;
-  // quic_disable_version_draft_25 flag
-  bool disable_version_draft_25_;
   // quic_enable_version_t051 flag
   bool enable_version_t051_;
   // quic_disable_version_t050 flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index eec910c..c91ad99 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -18,14 +18,13 @@
 class QuicVersionManagerTest : public QuicTest {};
 
 TEST_F(QuicVersionManagerTest, QuicVersionManager) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   for (const ParsedQuicVersion& version : AllSupportedVersions()) {
     QuicEnableVersion(version);
   }
   QuicDisableVersion(ParsedQuicVersion::Draft29());
   QuicDisableVersion(ParsedQuicVersion::Draft27());
-  QuicDisableVersion(ParsedQuicVersion::Draft25());
   QuicVersionManager manager(AllSupportedVersions());
 
   ParsedQuicVersionVector expected_parsed_versions;
@@ -74,19 +73,6 @@
   EXPECT_THAT(manager.GetSupportedAlpns(),
               ElementsAre("h3-29", "h3-27", "h3-T051", "h3-T050", "h3-Q050",
                           "h3-Q046", "h3-Q043"));
-
-  offset++;
-  QuicEnableVersion(ParsedQuicVersion::Draft25());
-  expected_parsed_versions.insert(expected_parsed_versions.begin() + offset,
-                                  ParsedQuicVersion::Draft25());
-  EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
-  EXPECT_EQ(expected_parsed_versions.size() - 3 - offset,
-            manager.GetSupportedVersionsWithQuicCrypto().size());
-  EXPECT_EQ(CurrentSupportedVersionsWithQuicCrypto(),
-            manager.GetSupportedVersionsWithQuicCrypto());
-  EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3-29", "h3-27", "h3-25", "h3-T051", "h3-T050",
-                          "h3-Q050", "h3-Q046", "h3-Q043"));
 }
 
 }  // namespace
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 93b5748..4b10cb7 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -40,7 +40,7 @@
 }
 
 void SetVersionFlag(const ParsedQuicVersion& version, bool should_enable) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   const bool enable = should_enable;
   const bool disable = !should_enable;
@@ -48,8 +48,6 @@
     SetQuicReloadableFlag(quic_disable_version_draft_29, disable);
   } else if (version == ParsedQuicVersion::Draft27()) {
     SetQuicReloadableFlag(quic_disable_version_draft_27, disable);
-  } else if (version == ParsedQuicVersion::Draft25()) {
-    SetQuicReloadableFlag(quic_disable_version_draft_25, disable);
   } else if (version == ParsedQuicVersion::T051()) {
     SetQuicReloadableFlag(quic_enable_version_t051, enable);
   } else if (version == ParsedQuicVersion::T050()) {
@@ -187,8 +185,7 @@
   DCHECK(IsKnown());
   // Variable-length integer transport parameters are supported in T051 and
   // all IETF drafts since draft-27.
-  return UsesTls() && transport_version > QUIC_VERSION_50 &&
-         transport_version != QUIC_VERSION_IETF_DRAFT_25;
+  return UsesTls() && transport_version > QUIC_VERSION_50;
 }
 
 bool ParsedQuicVersion::AuthenticatesHandshakeConnectionIds() const {
@@ -196,7 +193,6 @@
   // Authentication of handshake connection IDs is supported in T051 and
   // all IETF drafts since draft-28.
   return UsesTls() && transport_version > QUIC_VERSION_50 &&
-         transport_version != QUIC_VERSION_IETF_DRAFT_25 &&
          transport_version != QUIC_VERSION_IETF_DRAFT_27;
 }
 
@@ -241,14 +237,12 @@
 }
 
 QuicVersionLabel CreateQuicVersionLabel(ParsedQuicVersion parsed_version) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   if (parsed_version == ParsedQuicVersion::Draft29()) {
     return MakeVersionLabel(0xff, 0x00, 0x00, 29);
   } else if (parsed_version == ParsedQuicVersion::Draft27()) {
     return MakeVersionLabel(0xff, 0x00, 0x00, 27);
-  } else if (parsed_version == ParsedQuicVersion::Draft25()) {
-    return MakeVersionLabel(0xff, 0x00, 0x00, 25);
   } else if (parsed_version == ParsedQuicVersion::T051()) {
     return MakeVersionLabel('T', '0', '5', '1');
   } else if (parsed_version == ParsedQuicVersion::T050()) {
@@ -429,10 +423,6 @@
       if (!GetQuicReloadableFlag(quic_disable_version_draft_27)) {
         filtered_versions.push_back(version);
       }
-    } else if (version == ParsedQuicVersion::Draft25()) {
-      if (!GetQuicReloadableFlag(quic_disable_version_draft_25)) {
-        filtered_versions.push_back(version);
-      }
     } else if (version == ParsedQuicVersion::T051()) {
       if (GetQuicReloadableFlag(quic_enable_version_t051)) {
         filtered_versions.push_back(version);
@@ -541,14 +531,13 @@
     return #x
 
 std::string QuicVersionToString(QuicTransportVersion transport_version) {
-  static_assert(SupportedTransportVersions().size() == 7u,
+  static_assert(SupportedTransportVersions().size() == 6u,
                 "Supported versions out of sync");
   switch (transport_version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_43);
     RETURN_STRING_LITERAL(QUIC_VERSION_46);
     RETURN_STRING_LITERAL(QUIC_VERSION_50);
     RETURN_STRING_LITERAL(QUIC_VERSION_51);
-    RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_25);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_27);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_29);
     RETURN_STRING_LITERAL(QUIC_VERSION_UNSUPPORTED);
@@ -569,7 +558,7 @@
 }
 
 std::string ParsedQuicVersionToString(ParsedQuicVersion version) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   if (version == UnsupportedQuicVersion()) {
     return "0";
@@ -582,9 +571,6 @@
     } else if (version == ParsedQuicVersion::Draft27()) {
       DCHECK(version.UsesHttp3());
       return "draft27";
-    } else if (version == ParsedQuicVersion::Draft25()) {
-      DCHECK(version.UsesHttp3());
-      return "draft25";
     }
   }
   return QuicVersionLabelToString(CreateQuicVersionLabel(version));
@@ -675,8 +661,6 @@
     return "h3-29";
   } else if (parsed_version == ParsedQuicVersion::Draft27()) {
     return "h3-27";
-  } else if (parsed_version == ParsedQuicVersion::Draft25()) {
-    return "h3-25";
   }
   return "h3-" + ParsedQuicVersionToString(parsed_version);
 }
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 7ea590a..77b3359 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -118,7 +118,7 @@
   // header format from draft-ietf-quic-invariants-06
   QUIC_VERSION_50 = 50,  // Header protection and initial obfuscators.
   QUIC_VERSION_51 = 51,  // draft-29 features but with GoogleQUIC frames.
-  QUIC_VERSION_IETF_DRAFT_25 = 70,  // draft-ietf-quic-transport-25.
+  // Number 70 used to represent draft-ietf-quic-transport-25.
   QUIC_VERSION_IETF_DRAFT_27 = 71,  // draft-ietf-quic-transport-27.
   // Number 72 used to represent draft-ietf-quic-transport-28.
   QUIC_VERSION_IETF_DRAFT_29 = 73,  // draft-ietf-quic-transport-29.
@@ -136,10 +136,9 @@
 
 // This array contains QUIC transport versions which we currently support.
 // DEPRECATED. Use SupportedVersions() instead.
-constexpr std::array<QuicTransportVersion, 7> SupportedTransportVersions() {
+constexpr std::array<QuicTransportVersion, 6> SupportedTransportVersions() {
   return {QUIC_VERSION_IETF_DRAFT_29,
           QUIC_VERSION_IETF_DRAFT_27,
-          QUIC_VERSION_IETF_DRAFT_25,
           QUIC_VERSION_51,
           QUIC_VERSION_50,
           QUIC_VERSION_46,
@@ -200,7 +199,6 @@
     case PROTOCOL_QUIC_CRYPTO:
       return transport_version != QUIC_VERSION_UNSUPPORTED &&
              transport_version != QUIC_VERSION_51 &&
-             transport_version != QUIC_VERSION_IETF_DRAFT_25 &&
              transport_version != QUIC_VERSION_IETF_DRAFT_27 &&
              transport_version != QUIC_VERSION_IETF_DRAFT_29;
     case PROTOCOL_TLS1_3:
@@ -258,10 +256,6 @@
     return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27);
   }
 
-  static constexpr ParsedQuicVersion Draft25() {
-    return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_25);
-  }
-
   static constexpr ParsedQuicVersion T051() {
     return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_51);
   }
@@ -422,12 +416,12 @@
   return {PROTOCOL_TLS1_3, PROTOCOL_QUIC_CRYPTO};
 }
 
-constexpr std::array<ParsedQuicVersion, 8> SupportedVersions() {
+constexpr std::array<ParsedQuicVersion, 7> SupportedVersions() {
   return {
       ParsedQuicVersion::Draft29(), ParsedQuicVersion::Draft27(),
-      ParsedQuicVersion::Draft25(), ParsedQuicVersion::T051(),
-      ParsedQuicVersion::T050(),    ParsedQuicVersion::Q050(),
-      ParsedQuicVersion::Q046(),    ParsedQuicVersion::Q043(),
+      ParsedQuicVersion::T051(),    ParsedQuicVersion::T050(),
+      ParsedQuicVersion::Q050(),    ParsedQuicVersion::Q046(),
+      ParsedQuicVersion::Q043(),
   };
 }
 
@@ -499,14 +493,14 @@
 ParseQuicVersionLabel(QuicVersionLabel version_label);
 
 // Parses a QUIC version string such as "Q043" or "T050". Also supports parsing
-// ALPN such as "h3-25" or "h3-Q050". For PROTOCOL_QUIC_CRYPTO versions, also
+// ALPN such as "h3-29" or "h3-Q050". For PROTOCOL_QUIC_CRYPTO versions, also
 // supports parsing numbers such as "46".
 QUIC_EXPORT_PRIVATE ParsedQuicVersion
 ParseQuicVersionString(quiche::QuicheStringPiece version_string);
 
 // Parses a comma-separated list of QUIC version strings. Supports parsing by
 // label, ALPN and numbers for PROTOCOL_QUIC_CRYPTO. Skips unknown versions.
-// For example: "h3-25,Q050,46".
+// For example: "h3-29,Q050,46".
 QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
 ParseQuicVersionVectorString(quiche::QuicheStringPiece versions_string);
 
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index a79be65..1eff47a 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -245,11 +245,6 @@
     EXPECT_EQ(ParsedQuicVersion::Draft27(), ParseQuicVersionString("draft27"));
   }
   EXPECT_EQ(ParsedQuicVersion::Draft27(), ParseQuicVersionString("h3-27"));
-  EXPECT_EQ(ParsedQuicVersion::Draft25(), ParseQuicVersionString("ff000019"));
-  if (GetQuicReloadableFlag(quic_fix_print_draft_version)) {
-    EXPECT_EQ(ParsedQuicVersion::Draft25(), ParseQuicVersionString("draft25"));
-  }
-  EXPECT_EQ(ParsedQuicVersion::Draft25(), ParseQuicVersionString("h3-25"));
 
   for (const ParsedQuicVersion& version : AllSupportedVersions()) {
     EXPECT_EQ(version,
@@ -261,8 +256,6 @@
   ParsedQuicVersion version_q046(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46);
   ParsedQuicVersion version_q050(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50);
   ParsedQuicVersion version_t050(PROTOCOL_TLS1_3, QUIC_VERSION_50);
-  ParsedQuicVersion version_draft_25(PROTOCOL_TLS1_3,
-                                     QUIC_VERSION_IETF_DRAFT_25);
   ParsedQuicVersion version_draft_27(PROTOCOL_TLS1_3,
                                      QUIC_VERSION_IETF_DRAFT_27);
   ParsedQuicVersion version_draft_29 = ParsedQuicVersion::Draft29();
@@ -276,16 +269,14 @@
   EXPECT_THAT(ParseQuicVersionVectorString("h3-T050"),
               ElementsAre(version_t050));
 
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-25, h3-27"),
-              ElementsAre(version_draft_25, version_draft_27));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-25,h3-27"),
-              ElementsAre(version_draft_25, version_draft_27));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-25,h3-27,h3-25"),
-              ElementsAre(version_draft_25, version_draft_27));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-25,h3-27, h3-25"),
-              ElementsAre(version_draft_25, version_draft_27));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-27,h3-25"),
-              ElementsAre(version_draft_27, version_draft_25));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-27, h3-29"),
+              ElementsAre(version_draft_27, version_draft_29));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-27,h3-29"),
+              ElementsAre(version_draft_29, version_draft_27));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-27, h3-29"),
+              ElementsAre(version_draft_29, version_draft_27));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-27,h3-29"),
+              ElementsAre(version_draft_27, version_draft_29));
   EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-27"),
               ElementsAre(version_draft_29, version_draft_27));
 
@@ -328,8 +319,8 @@
   EXPECT_THAT(ParseQuicVersionVectorString("99"), IsEmpty());
   EXPECT_THAT(ParseQuicVersionVectorString("70"), IsEmpty());
   EXPECT_THAT(ParseQuicVersionVectorString("h3-01"), IsEmpty());
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-01,h3-25"),
-              ElementsAre(version_draft_25));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-01,h3-29"),
+              ElementsAre(version_draft_29));
 }
 
 TEST_F(QuicVersionsTest, CreateQuicVersionLabel) {
@@ -417,15 +408,11 @@
   EXPECT_EQ("Q050", ParsedQuicVersionToString(ParsedQuicVersion::Q050()));
   EXPECT_EQ("T050", ParsedQuicVersionToString(ParsedQuicVersion::T050()));
   if (GetQuicReloadableFlag(quic_fix_print_draft_version)) {
-    EXPECT_EQ("draft25",
-              ParsedQuicVersionToString(ParsedQuicVersion::Draft25()));
     EXPECT_EQ("draft27",
               ParsedQuicVersionToString(ParsedQuicVersion::Draft27()));
     EXPECT_EQ("draft29",
               ParsedQuicVersionToString(ParsedQuicVersion::Draft29()));
   } else {
-    EXPECT_EQ("ff000019",
-              ParsedQuicVersionToString(ParsedQuicVersion::Draft25()));
     EXPECT_EQ("ff00001b",
               ParsedQuicVersionToString(ParsedQuicVersion::Draft27()));
     EXPECT_EQ("ff00001d",
@@ -520,26 +507,24 @@
 // yet a typo was made in doing the #defines and it was caught
 // only in some test far removed from here... Better safe than sorry.
 TEST_F(QuicVersionsTest, CheckTransportVersionNumbersForTypos) {
-  static_assert(SupportedTransportVersions().size() == 7u,
+  static_assert(SupportedTransportVersions().size() == 6u,
                 "Supported versions out of sync");
   EXPECT_EQ(QUIC_VERSION_43, 43);
   EXPECT_EQ(QUIC_VERSION_46, 46);
   EXPECT_EQ(QUIC_VERSION_50, 50);
   EXPECT_EQ(QUIC_VERSION_51, 51);
-  EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_25, 70);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_27, 71);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_29, 73);
 }
 
 TEST_F(QuicVersionsTest, AlpnForVersion) {
-  static_assert(SupportedVersions().size() == 8u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   EXPECT_EQ("h3-Q043", AlpnForVersion(ParsedQuicVersion::Q043()));
   EXPECT_EQ("h3-Q046", AlpnForVersion(ParsedQuicVersion::Q046()));
   EXPECT_EQ("h3-Q050", AlpnForVersion(ParsedQuicVersion::Q050()));
   EXPECT_EQ("h3-T050", AlpnForVersion(ParsedQuicVersion::T050()));
   EXPECT_EQ("h3-T051", AlpnForVersion(ParsedQuicVersion::T051()));
-  EXPECT_EQ("h3-25", AlpnForVersion(ParsedQuicVersion::Draft25()));
   EXPECT_EQ("h3-27", AlpnForVersion(ParsedQuicVersion::Draft27()));
   EXPECT_EQ("h3-29", AlpnForVersion(ParsedQuicVersion::Draft29()));
 }