diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index cc479ab..50bbfef 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -146,10 +146,6 @@
 const uint8_t kQ050Salt[] = {0x50, 0x45, 0x74, 0xef, 0xd0, 0x66, 0xfe,
                              0x2f, 0x9d, 0x94, 0x5c, 0xfc, 0xdb, 0xd3,
                              0xa7, 0xf0, 0xd3, 0xb5, 0x6b, 0x45};
-// Salt to use for initial obfuscators in version T051.
-const uint8_t kT051Salt[] = {0x7a, 0x4e, 0xde, 0xf4, 0xe7, 0xcc, 0xee,
-                             0x5f, 0xa4, 0x50, 0x6c, 0x19, 0x12, 0x4f,
-                             0xc8, 0xcc, 0xda, 0x6e, 0x03, 0x3d};
 // Salt to use for initial obfuscators in
 // ParsedQuicVersion::ReservedForNegotiation().
 const uint8_t kReservedForNegotiationSalt[] = {
@@ -158,7 +154,7 @@
 
 const uint8_t* InitialSaltForVersion(const ParsedQuicVersion& version,
                                      size_t* out_len) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync with initial encryption salts");
   if (version == ParsedQuicVersion::RFCv1()) {
     *out_len = ABSL_ARRAYSIZE(kRFCv1InitialSalt);
@@ -166,9 +162,6 @@
   } else if (version == ParsedQuicVersion::Draft29()) {
     *out_len = ABSL_ARRAYSIZE(kDraft29InitialSalt);
     return kDraft29InitialSalt;
-  } else if (version == ParsedQuicVersion::T051()) {
-    *out_len = ABSL_ARRAYSIZE(kT051Salt);
-    return kT051Salt;
   } else if (version == ParsedQuicVersion::Q050()) {
     *out_len = ABSL_ARRAYSIZE(kQ050Salt);
     return kQ050Salt;
@@ -186,6 +179,8 @@
 
 // Retry Integrity Protection Keys and Nonces.
 // https://tools.ietf.org/html/draft-ietf-quic-tls-29#section-5.8
+// When introducing a new Google version, generate a new key by running
+// `openssl rand -hex 16`.
 const uint8_t kDraft29RetryIntegrityKey[] = {0xcc, 0xce, 0x18, 0x7e, 0xd0, 0x9a,
                                              0x09, 0xd0, 0x57, 0x28, 0x15, 0x5a,
                                              0x6c, 0xb9, 0x6b, 0xe1};
@@ -196,20 +191,12 @@
                                            0xe3, 0x68, 0xc8, 0x4e};
 const uint8_t kRFCv1RetryIntegrityNonce[] = {
     0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb};
-
-// Keys used by Google versions of QUIC. When introducing a new version,
-// generate a new key by running `openssl rand -hex 16`.
-const uint8_t kT051RetryIntegrityKey[] = {0x2e, 0xb9, 0x61, 0xa6, 0x79, 0x56,
-                                          0xf8, 0x79, 0x53, 0x14, 0xda, 0xfb,
-                                          0x2e, 0xbc, 0x83, 0xd7};
 // Retry integrity key used by ParsedQuicVersion::ReservedForNegotiation().
 const uint8_t kReservedForNegotiationRetryIntegrityKey[] = {
     0xf2, 0xcd, 0x8f, 0xe0, 0x36, 0xd0, 0x25, 0x35,
     0x03, 0xe6, 0x7c, 0x7b, 0xd2, 0x44, 0xca, 0xd9};
-// Nonces used by Google versions of QUIC. When introducing a new version,
-// generate a new nonce by running `openssl rand -hex 12`.
-const uint8_t kT051RetryIntegrityNonce[] = {0xb5, 0x0e, 0x4e, 0x53, 0x4c, 0xfc,
-                                            0x0b, 0xbb, 0x85, 0xf2, 0xf9, 0xca};
+// When introducing a new Google version, generate a new nonce by running
+// `openssl rand -hex 12`.
 // Retry integrity nonce used by ParsedQuicVersion::ReservedForNegotiation().
 const uint8_t kReservedForNegotiationRetryIntegrityNonce[] = {
     0x35, 0x9f, 0x16, 0xd1, 0xed, 0x80, 0x90, 0x8e, 0xec, 0x85, 0xc4, 0xd6};
@@ -217,7 +204,7 @@
 bool RetryIntegrityKeysForVersion(const ParsedQuicVersion& version,
                                   absl::string_view* key,
                                   absl::string_view* nonce) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync with retry integrity keys");
   if (!version.UsesTls()) {
     QUIC_BUG(quic_bug_10699_2)
@@ -240,14 +227,6 @@
         reinterpret_cast<const char*>(kDraft29RetryIntegrityNonce),
         ABSL_ARRAYSIZE(kDraft29RetryIntegrityNonce));
     return true;
-  } else if (version == ParsedQuicVersion::T051()) {
-    *key =
-        absl::string_view(reinterpret_cast<const char*>(kT051RetryIntegrityKey),
-                          ABSL_ARRAYSIZE(kT051RetryIntegrityKey));
-    *nonce = absl::string_view(
-        reinterpret_cast<const char*>(kT051RetryIntegrityNonce),
-        ABSL_ARRAYSIZE(kT051RetryIntegrityNonce));
-    return true;
   } else if (version == ParsedQuicVersion::ReservedForNegotiation()) {
     *key = absl::string_view(
         reinterpret_cast<const char*>(kReservedForNegotiationRetryIntegrityKey),
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 4d59c13..66cfcb3 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -1503,7 +1503,25 @@
                              received_packet44);
 }
 
-static_assert(quic::SupportedVersions().size() == 6u,
+TEST_P(QuicDispatcherTestOneVersion,
+       RejectDeprecatedVersionT051WithVersionNegotiation) {
+  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  CreateTimeWaitListManager();
+  uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
+      0xFF, 'T', '0', '5', '1', /*destination connection ID length*/ 0x08};
+  QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
+                                     kMinPacketSizeForVersionNegotiation,
+                                     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);
+}
+
+static_assert(quic::SupportedVersions().size() == 5u,
               "Please add new RejectDeprecatedVersion tests above this assert "
               "when deprecating versions");
 
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 37da0e8..af9c02c 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -59,8 +59,6 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_rfcv1, false)
 // If true, disable QUIC version h3-29.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_draft_29, false)
-// If true, disable QUIC version h3-T051.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_t051, true)
 // If true, disable blackhole detection on server side.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_server_blackhole_detection, false)
 // If true, discard INITIAL packet if the key has been dropped.
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 1c8784b..3aa821c 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -15,10 +15,7 @@
 
 QuicVersionManager::QuicVersionManager(
     ParsedQuicVersionVector supported_versions)
-    : allowed_supported_versions_(std::move(supported_versions)) {
-  static_assert(SupportedVersions().size() == 6u,
-                "Supported versions out of sync");
-}
+    : allowed_supported_versions_(std::move(supported_versions)) {}
 
 QuicVersionManager::~QuicVersionManager() {}
 
@@ -45,14 +42,12 @@
 }
 
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   if (disable_version_rfcv1_ !=
           GetQuicReloadableFlag(quic_disable_version_rfcv1) ||
       disable_version_draft_29_ !=
           GetQuicReloadableFlag(quic_disable_version_draft_29) ||
-      disable_version_t051_ !=
-          GetQuicReloadableFlag(quic_disable_version_t051) ||
       disable_version_q050_ !=
           GetQuicReloadableFlag(quic_disable_version_q050) ||
       disable_version_q046_ !=
@@ -62,7 +57,6 @@
     disable_version_rfcv1_ = GetQuicReloadableFlag(quic_disable_version_rfcv1);
     disable_version_draft_29_ =
         GetQuicReloadableFlag(quic_disable_version_draft_29);
-    disable_version_t051_ = GetQuicReloadableFlag(quic_disable_version_t051);
     disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
     disable_version_q046_ = GetQuicReloadableFlag(quic_disable_version_q046);
     disable_version_q043_ = GetQuicReloadableFlag(quic_disable_version_q043);
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index 50c61eb..a3ae719 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -62,8 +62,6 @@
   bool disable_version_rfcv1_ = true;
   // quic_disable_version_draft_29 flag
   bool disable_version_draft_29_ = true;
-  // quic_disable_version_t051 flag
-  bool disable_version_t051_ = true;
   // quic_disable_version_q050 flag
   bool disable_version_q050_ = true;
   // quic_disable_version_q046 flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 75ceed4..8960bce 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() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   for (const ParsedQuicVersion& version : AllSupportedVersions()) {
     QuicEnableVersion(version);
   }
   QuicDisableVersion(ParsedQuicVersion::RFCv1());
   QuicDisableVersion(ParsedQuicVersion::Draft29());
-  QuicDisableVersion(ParsedQuicVersion::T051());
   QuicVersionManager manager(AllSupportedVersions());
 
   ParsedQuicVersionVector expected_parsed_versions;
@@ -45,7 +44,7 @@
 
   int offset = 0;
   QuicEnableVersion(ParsedQuicVersion::Draft29());
-  expected_parsed_versions.insert(expected_parsed_versions.begin() + offset,
+  expected_parsed_versions.insert(expected_parsed_versions.begin(),
                                   ParsedQuicVersion::Draft29());
   EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
   EXPECT_EQ(expected_parsed_versions.size() - 1 - offset,
@@ -61,21 +60,21 @@
               ElementsAre("h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
 
   offset++;
-  QuicEnableVersion(ParsedQuicVersion::T051());
-  expected_parsed_versions.insert(expected_parsed_versions.begin() + offset,
-                                  ParsedQuicVersion::T051());
+  QuicEnableVersion(ParsedQuicVersion::RFCv1());
+  expected_parsed_versions.insert(expected_parsed_versions.begin(),
+                                  ParsedQuicVersion::RFCv1());
   EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
   EXPECT_EQ(expected_parsed_versions.size() - 1 - offset,
             manager.GetSupportedVersionsWithQuicCrypto().size());
   EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
             manager.GetSupportedVersions());
-  EXPECT_EQ(1u, manager.GetSupportedVersionsWithOnlyHttp3().size());
+  EXPECT_EQ(2u, manager.GetSupportedVersionsWithOnlyHttp3().size());
   EXPECT_EQ(CurrentSupportedHttp3Versions(),
             manager.GetSupportedVersionsWithOnlyHttp3());
   EXPECT_EQ(CurrentSupportedVersionsWithQuicCrypto(),
             manager.GetSupportedVersionsWithQuicCrypto());
   EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3-29", "h3-T051", "h3-Q050", "h3-Q046", "h3-Q043"));
+              ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
 }
 
 }  // namespace
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index cff0b92..4c9e661 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -42,7 +42,7 @@
 }
 
 void SetVersionFlag(const ParsedQuicVersion& version, bool should_enable) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   const bool enable = should_enable;
   const bool disable = !should_enable;
@@ -50,8 +50,6 @@
     SetQuicReloadableFlag(quic_disable_version_rfcv1, disable);
   } else if (version == ParsedQuicVersion::Draft29()) {
     SetQuicReloadableFlag(quic_disable_version_draft_29, disable);
-  } else if (version == ParsedQuicVersion::T051()) {
-    SetQuicReloadableFlag(quic_disable_version_t051, disable);
   } else if (version == ParsedQuicVersion::Q050()) {
     SetQuicReloadableFlag(quic_disable_version_q050, disable);
   } else if (version == ParsedQuicVersion::Q046()) {
@@ -215,14 +213,12 @@
 }
 
 QuicVersionLabel CreateQuicVersionLabel(ParsedQuicVersion parsed_version) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   if (parsed_version == ParsedQuicVersion::RFCv1()) {
     return MakeVersionLabel(0x00, 0x00, 0x00, 0x01);
   } else if (parsed_version == ParsedQuicVersion::Draft29()) {
     return MakeVersionLabel(0xff, 0x00, 0x00, 29);
-  } else if (parsed_version == ParsedQuicVersion::T051()) {
-    return MakeVersionLabel('T', '0', '5', '1');
   } else if (parsed_version == ParsedQuicVersion::Q050()) {
     return MakeVersionLabel('Q', '0', '5', '0');
   } else if (parsed_version == ParsedQuicVersion::Q046()) {
@@ -426,10 +422,6 @@
       if (!GetQuicReloadableFlag(quic_disable_version_draft_29)) {
         filtered_versions.push_back(version);
       }
-    } else if (version == ParsedQuicVersion::T051()) {
-      if (!GetQuicReloadableFlag(quic_disable_version_t051)) {
-        filtered_versions.push_back(version);
-      }
     } else if (version == ParsedQuicVersion::Q050()) {
       if (!GetQuicReloadableFlag(quic_disable_version_q050)) {
         filtered_versions.push_back(version);
@@ -496,7 +488,6 @@
     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_29);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_RFC_V1);
     RETURN_STRING_LITERAL(QUIC_VERSION_UNSUPPORTED);
@@ -517,7 +508,7 @@
 }
 
 std::string ParsedQuicVersionToString(ParsedQuicVersion version) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   if (version == UnsupportedQuicVersion()) {
     return "0";
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 695258e..331a99c 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -118,14 +118,14 @@
   // Version 49 added client connection IDs, long header lengths, and the IETF
   // 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.
+  // Number 51 was T051 which used draft-29 features but with GoogleQUIC frames.
   // Number 70 used to represent draft-ietf-quic-transport-25.
   // Number 71 used to represent 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.
-  QUIC_VERSION_IETF_RFC_V1 = 80,    // Not-yet-published RFC.
+  QUIC_VERSION_IETF_RFC_V1 = 80,    // RFC 9000.
   // Version 99 was a dumping ground for IETF QUIC changes which were not yet
-  // yet ready for production between 2018-02 and 2020-02.
+  // ready for production between 2018-02 and 2020-02.
 
   // QUIC_VERSION_RESERVED_FOR_NEGOTIATION is sent over the wire as ?a?a?a?a
   // which is part of a range reserved by the IETF for version negotiation
@@ -173,7 +173,6 @@
   constexpr QuicTransportVersion valid_transport_versions[] = {
       QUIC_VERSION_IETF_RFC_V1,
       QUIC_VERSION_IETF_DRAFT_29,
-      QUIC_VERSION_51,
       QUIC_VERSION_50,
       QUIC_VERSION_46,
       QUIC_VERSION_43,
@@ -195,7 +194,6 @@
     case PROTOCOL_QUIC_CRYPTO:
       return transport_version != QUIC_VERSION_UNSUPPORTED &&
              transport_version != QUIC_VERSION_RESERVED_FOR_NEGOTIATION &&
-             transport_version != QUIC_VERSION_51 &&
              transport_version != QUIC_VERSION_IETF_DRAFT_29 &&
              transport_version != QUIC_VERSION_IETF_RFC_V1;
     case PROTOCOL_TLS1_3:
@@ -255,10 +253,6 @@
     return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_29);
   }
 
-  static constexpr ParsedQuicVersion T051() {
-    return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_51);
-  }
-
   static constexpr ParsedQuicVersion Q050() {
     return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50);
   }
@@ -400,11 +394,11 @@
   return {PROTOCOL_TLS1_3, PROTOCOL_QUIC_CRYPTO};
 }
 
-constexpr std::array<ParsedQuicVersion, 6> SupportedVersions() {
+constexpr std::array<ParsedQuicVersion, 5> SupportedVersions() {
   return {
       ParsedQuicVersion::RFCv1(), ParsedQuicVersion::Draft29(),
-      ParsedQuicVersion::T051(),  ParsedQuicVersion::Q050(),
-      ParsedQuicVersion::Q046(),  ParsedQuicVersion::Q043(),
+      ParsedQuicVersion::Q050(),  ParsedQuicVersion::Q046(),
+      ParsedQuicVersion::Q043(),
   };
 }
 
@@ -571,7 +565,7 @@
 // * GOAWAY is moved to HTTP layer.
 QUIC_EXPORT_PRIVATE constexpr bool VersionUsesHttp3(
     QuicTransportVersion transport_version) {
-  return transport_version > QUIC_VERSION_51;
+  return transport_version >= QUIC_VERSION_IETF_DRAFT_29;
 }
 
 // Returns whether the transport_version supports the variable length integer
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index 0ee3b4f..60790d6 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -117,8 +117,6 @@
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '6')));
   EXPECT_EQ(ParsedQuicVersion::Q050(),
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '5', '0')));
-  EXPECT_EQ(ParsedQuicVersion::T051(),
-            ParseQuicVersionLabel(MakeVersionLabel('T', '0', '5', '1')));
   EXPECT_EQ(ParsedQuicVersion::Draft29(),
             ParseQuicVersionLabel(MakeVersionLabel(0xff, 0x00, 0x00, 0x1d)));
   EXPECT_EQ(ParsedQuicVersion::RFCv1(),
@@ -140,8 +138,6 @@
   EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionString("Q050"));
   EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionString("50"));
   EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionString("h3-Q050"));
-  EXPECT_EQ(ParsedQuicVersion::T051(), ParseQuicVersionString("T051"));
-  EXPECT_EQ(ParsedQuicVersion::T051(), ParseQuicVersionString("h3-T051"));
 
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString(""));
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("Q 46"));
@@ -162,7 +158,6 @@
 TEST_F(QuicVersionsTest, ParseQuicVersionVectorString) {
   ParsedQuicVersion version_q046 = ParsedQuicVersion::Q046();
   ParsedQuicVersion version_q050 = ParsedQuicVersion::Q050();
-  ParsedQuicVersion version_t051 = ParsedQuicVersion::T051();
   ParsedQuicVersion version_draft_29 = ParsedQuicVersion::Draft29();
 
   EXPECT_THAT(ParseQuicVersionVectorString(""), IsEmpty());
@@ -171,36 +166,22 @@
               ElementsAre(version_q050));
   EXPECT_THAT(ParseQuicVersionVectorString("h3-Q050"),
               ElementsAre(version_q050));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051"),
-              ElementsAre(version_t051));
-
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051, h3-29"),
-              ElementsAre(version_t051, version_draft_29));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-T051,h3-29"),
-              ElementsAre(version_draft_29, version_t051));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-T051, h3-29"),
-              ElementsAre(version_draft_29, version_t051));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051,h3-29"),
-              ElementsAre(version_t051, version_draft_29));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-T051"),
-              ElementsAre(version_draft_29, version_t051));
-
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051,50"),
-              ElementsAre(version_t051, version_q050));
-
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-Q050, h3-T051"),
-              ElementsAre(version_q050, version_t051));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051, h3-Q050"),
-              ElementsAre(version_t051, version_q050));
-  EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_50,h3-T051"),
-              ElementsAre(version_q050, version_t051));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051,QUIC_VERSION_50"),
-              ElementsAre(version_t051, version_q050));
-  EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_50, h3-T051"),
-              ElementsAre(version_q050, version_t051));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051, QUIC_VERSION_50"),
-              ElementsAre(version_t051, version_q050));
-
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-Q050, h3-29"),
+              ElementsAre(version_q050, version_draft_29));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-Q050,h3-29"),
+              ElementsAre(version_draft_29, version_q050));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-Q050, h3-29"),
+              ElementsAre(version_draft_29, version_q050));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-29, h3-Q050"),
+              ElementsAre(version_draft_29, version_q050));
+  EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_50,h3-29"),
+              ElementsAre(version_q050, version_draft_29));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-29,QUIC_VERSION_50"),
+              ElementsAre(version_draft_29, version_q050));
+  EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_50, h3-29"),
+              ElementsAre(version_q050, version_draft_29));
+  EXPECT_THAT(ParseQuicVersionVectorString("h3-29, QUIC_VERSION_50"),
+              ElementsAre(version_draft_29, version_q050));
   EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_50,QUIC_VERSION_46"),
               ElementsAre(version_q050, version_q046));
   EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_46,QUIC_VERSION_50"),
@@ -211,15 +192,13 @@
               ElementsAre(version_q050));
   EXPECT_THAT(ParseQuicVersionVectorString("h3-Q050, h3-Q050"),
               ElementsAre(version_q050));
-  EXPECT_THAT(ParseQuicVersionVectorString("h3-T051, h3-T051"),
-              ElementsAre(version_t051));
   EXPECT_THAT(ParseQuicVersionVectorString("h3-Q050, QUIC_VERSION_50"),
               ElementsAre(version_q050));
   EXPECT_THAT(ParseQuicVersionVectorString(
                   "QUIC_VERSION_50, h3-Q050, QUIC_VERSION_50, h3-Q050"),
               ElementsAre(version_q050));
-  EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_50, h3-T051, h3-Q050"),
-              ElementsAre(version_q050, version_t051));
+  EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_50, h3-29, h3-Q050"),
+              ElementsAre(version_q050, version_draft_29));
 
   EXPECT_THAT(ParseQuicVersionVectorString("99"), IsEmpty());
   EXPECT_THAT(ParseQuicVersionVectorString("70"), IsEmpty());
@@ -235,10 +214,10 @@
             CreateQuicVersionLabel(ParsedQuicVersion::Q046()));
   EXPECT_EQ(MakeVersionLabel('Q', '0', '5', '0'),
             CreateQuicVersionLabel(ParsedQuicVersion::Q050()));
-
-  // Test a TLS version:
-  EXPECT_EQ(MakeVersionLabel('T', '0', '5', '1'),
-            CreateQuicVersionLabel(ParsedQuicVersion::T051()));
+  EXPECT_EQ(MakeVersionLabel(0xff, 0x00, 0x00, 0x1d),
+            CreateQuicVersionLabel(ParsedQuicVersion::Draft29()));
+  EXPECT_EQ(MakeVersionLabel(0x00, 0x00, 0x00, 0x01),
+            CreateQuicVersionLabel(ParsedQuicVersion::RFCv1()));
 
   // Make sure the negotiation reserved version is in the IETF reserved space.
   EXPECT_EQ(
@@ -311,8 +290,8 @@
   EXPECT_EQ("Q043", ParsedQuicVersionToString(ParsedQuicVersion::Q043()));
   EXPECT_EQ("Q046", ParsedQuicVersionToString(ParsedQuicVersion::Q046()));
   EXPECT_EQ("Q050", ParsedQuicVersionToString(ParsedQuicVersion::Q050()));
-  EXPECT_EQ("T051", ParsedQuicVersionToString(ParsedQuicVersion::T051()));
   EXPECT_EQ("draft29", ParsedQuicVersionToString(ParsedQuicVersion::Draft29()));
+  EXPECT_EQ("RFCv1", ParsedQuicVersionToString(ParsedQuicVersion::RFCv1()));
 
   ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q043()};
   EXPECT_EQ("Q043", ParsedQuicVersionVectorToString(versions_vector));
@@ -379,23 +358,21 @@
 // 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(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "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_29, 73);
   EXPECT_EQ(QUIC_VERSION_IETF_RFC_V1, 80);
 }
 
 TEST_F(QuicVersionsTest, AlpnForVersion) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "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-T051", AlpnForVersion(ParsedQuicVersion::T051()));
   EXPECT_EQ("h3-29", AlpnForVersion(ParsedQuicVersion::Draft29()));
   EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::RFCv1()));
 }