diff --git a/quiche/quic/core/crypto/crypto_utils.cc b/quiche/quic/core/crypto/crypto_utils.cc
index 428edb7..01fb681 100644
--- a/quiche/quic/core/crypto/crypto_utils.cc
+++ b/quiche/quic/core/crypto/crypto_utils.cc
@@ -96,7 +96,7 @@
                                      const absl::string_view& predicate) {
   static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync with HKDF labels");
-  if (version == ParsedQuicVersion::V2Draft01()) {
+  if (version == ParsedQuicVersion::V2Draft08()) {
     return absl::StrCat("quicv2 ", predicate);
   } else {
     return absl::StrCat("quic ", predicate);
@@ -152,9 +152,10 @@
 const uint8_t kRFCv1InitialSalt[] = {0x38, 0x76, 0x2c, 0xf7, 0xf5, 0x59, 0x34,
                                      0xb3, 0x4d, 0x17, 0x9a, 0xe6, 0xa4, 0xc8,
                                      0x0c, 0xad, 0xcc, 0xbb, 0x7f, 0x0a};
-const uint8_t kV2Draft01InitialSalt[] = {
-    0xa7, 0x07, 0xc2, 0x03, 0xa5, 0x9b, 0x47, 0x18, 0x4a, 0x1d,
-    0x62, 0xca, 0x57, 0x04, 0x06, 0xea, 0x7a, 0xe3, 0xe5, 0xd3};
+const uint8_t kV2Draft08InitialSalt[] = {
+    0x0d, 0xed, 0xe3, 0xde, 0xf7, 0x00, 0xa6, 0xdb, 0x81, 0x93,
+    0x81, 0xbe, 0x6e, 0x26, 0x9d, 0xcb, 0xf9, 0xbd, 0x2e, 0xd9,
+};
 
 // Salts used by deployed versions of QUIC. When introducing a new version,
 // generate a new salt by running `openssl rand -hex 20`.
@@ -173,9 +174,9 @@
                                      size_t* out_len) {
   static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync with initial encryption salts");
-  if (version == ParsedQuicVersion::V2Draft01()) {
-    *out_len = ABSL_ARRAYSIZE(kV2Draft01InitialSalt);
-    return kV2Draft01InitialSalt;
+  if (version == ParsedQuicVersion::V2Draft08()) {
+    *out_len = ABSL_ARRAYSIZE(kV2Draft08InitialSalt);
+    return kV2Draft08InitialSalt;
   } else if (version == ParsedQuicVersion::RFCv1()) {
     *out_len = ABSL_ARRAYSIZE(kRFCv1InitialSalt);
     return kRFCv1InitialSalt;
@@ -211,11 +212,11 @@
                                            0xe3, 0x68, 0xc8, 0x4e};
 const uint8_t kRFCv1RetryIntegrityNonce[] = {
     0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb};
-const uint8_t kV2Draft01RetryIntegrityKey[] = {
-    0xba, 0x85, 0x8d, 0xc7, 0xb4, 0x3d, 0xe5, 0xdb,
-    0xf8, 0x76, 0x17, 0xff, 0x4a, 0xb2, 0x53, 0xdb};
-const uint8_t kV2Draft01RetryIntegrityNonce[] = {
-    0x14, 0x1b, 0x99, 0xc2, 0x39, 0xb0, 0x3e, 0x78, 0x5d, 0x6a, 0x2e, 0x9f};
+const uint8_t kV2Draft08RetryIntegrityKey[] = {
+    0x8f, 0xb4, 0xb0, 0x1b, 0x56, 0xac, 0x48, 0xe2,
+    0x60, 0xfb, 0xcb, 0xce, 0xad, 0x7c, 0xcc, 0x92};
+const uint8_t kV2Draft08RetryIntegrityNonce[] = {
+    0xd8, 0x69, 0x69, 0xbc, 0x2d, 0x7c, 0x6d, 0x99, 0x90, 0xef, 0xb0, 0x4a};
 // Retry integrity key used by ParsedQuicVersion::ReservedForNegotiation().
 const uint8_t kReservedForNegotiationRetryIntegrityKey[] = {
     0xf2, 0xcd, 0x8f, 0xe0, 0x36, 0xd0, 0x25, 0x35,
@@ -236,13 +237,13 @@
         << "Attempted to get retry integrity keys for invalid version "
         << version;
     return false;
-  } else if (version == ParsedQuicVersion::V2Draft01()) {
+  } else if (version == ParsedQuicVersion::V2Draft08()) {
     *key = absl::string_view(
-        reinterpret_cast<const char*>(kV2Draft01RetryIntegrityKey),
-        ABSL_ARRAYSIZE(kV2Draft01RetryIntegrityKey));
+        reinterpret_cast<const char*>(kV2Draft08RetryIntegrityKey),
+        ABSL_ARRAYSIZE(kV2Draft08RetryIntegrityKey));
     *nonce = absl::string_view(
-        reinterpret_cast<const char*>(kV2Draft01RetryIntegrityNonce),
-        ABSL_ARRAYSIZE(kV2Draft01RetryIntegrityNonce));
+        reinterpret_cast<const char*>(kV2Draft08RetryIntegrityNonce),
+        ABSL_ARRAYSIZE(kV2Draft08RetryIntegrityNonce));
     return true;
   } else if (version == ParsedQuicVersion::RFCv1()) {
     *key = absl::string_view(
diff --git a/quiche/quic/core/crypto/crypto_utils_test.cc b/quiche/quic/core/crypto/crypto_utils_test.cc
index 6452367..505ee75 100644
--- a/quiche/quic/core/crypto/crypto_utils_test.cc
+++ b/quiche/quic/core/crypto/crypto_utils_test.cc
@@ -208,23 +208,23 @@
                          0x06,
                          0x7e,
                          0x37};
-  const char v2_01_key[] = {// test vector from draft-ietf-quic-v2-01
-                            0x15,
+  const char v2_08_key[] = {// test vector from draft-ietf-quic-v2-08
+                            0x82,
+                            static_cast<char>(0xdb),
+                            static_cast<char>(0x63),
+                            static_cast<char>(0x78),
+                            static_cast<char>(0x61),
                             static_cast<char>(0xd5),
-                            static_cast<char>(0xb4),
-                            static_cast<char>(0xd9),
-                            static_cast<char>(0xa2),
-                            static_cast<char>(0xb8),
-                            static_cast<char>(0x91),
-                            0x6a,
-                            static_cast<char>(0xa3),
-                            static_cast<char>(0x9b),
-                            0x1b,
-                            static_cast<char>(0xfe),
-                            0x57,
-                            0x4d,
-                            0x2a,
-                            static_cast<char>(0xad)};
+                            static_cast<char>(0x5e),
+                            0x1d,
+                            static_cast<char>(0x01),
+                            static_cast<char>(0x1f),
+                            0x19,
+                            static_cast<char>(0xea),
+                            0x71,
+                            0xd5,
+                            0xd2,
+                            static_cast<char>(0xa7)};
   const char connection_id[] =  // test vector from both docs
       {static_cast<char>(0x83),
        static_cast<char>(0x94),
@@ -245,8 +245,8 @@
       key_str = v1_key;
       key_size = sizeof(v1_key);
     } else {  // draft-ietf-quic-v2-01
-      key_str = v2_01_key;
-      key_size = sizeof(v2_01_key);
+      key_str = v2_08_key;
+      key_size = sizeof(v2_08_key);
     }
     const absl::string_view expected_key{key_str, key_size};
 
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 430954c..4acdea7 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -10122,9 +10122,9 @@
 
   // These values come from draft-ietf-quic-v2 Appendix A.4.
   uint8_t retry_packet_rfcv2[] = {
-      0xcf, 0x70, 0x9a, 0x50, 0xc4, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
-      0x42, 0x62, 0xb5, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x1d, 0xc7, 0x11, 0x30,
-      0xcd, 0x1e, 0xd3, 0x9d, 0x6e, 0xfc, 0xee, 0x5c, 0x85, 0x80, 0x65, 0x01};
+      0xcf, 0x6b, 0x33, 0x43, 0xcf, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
+      0x42, 0x62, 0xb5, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0xc8, 0x64, 0x6c, 0xe8,
+      0xbf, 0xe3, 0x39, 0x52, 0xd9, 0x55, 0x54, 0x36, 0x65, 0xdc, 0xc7, 0xb6};
   // These values come from RFC9001 Appendix A.4.
   uint8_t retry_packet_rfcv1[] = {
       0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
@@ -10137,7 +10137,7 @@
 
   uint8_t* retry_packet;
   size_t retry_packet_length;
-  if (version() == ParsedQuicVersion::V2Draft01()) {
+  if (version() == ParsedQuicVersion::V2Draft08()) {
     retry_packet = retry_packet_rfcv2;
     retry_packet_length = ABSL_ARRAYSIZE(retry_packet_rfcv2);
   } else if (version() == ParsedQuicVersion::RFCv1()) {
diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index c962208..653029c 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -87,8 +87,8 @@
 QUIC_FLAG(quic_reloadable_flag_quic_conservative_cwnd_and_pacing_gains, false)
 // When true, defaults to BBR congestion control instead of Cubic.
 QUIC_FLAG(quic_reloadable_flag_quic_default_to_bbr, false)
-// When true, support draft-ietf-quic-v2-01
-QUIC_FLAG(quic_reloadable_flag_quic_enable_version_2_draft_01, false)
+// When true, support draft-ietf-quic-v2-08
+QUIC_FLAG(quic_reloadable_flag_quic_enable_version_2_draft_08, false)
 // When true, the BB2U copt causes BBR2 to wait two rounds with out draining the queue before exiting PROBE_UP and BB2S has the same effect in STARTUP.
 QUIC_FLAG(quic_reloadable_flag_quic_bbr2_probe_two_rounds, true)
 // When true, the BBHI copt causes QUIC BBRv2 to use a simpler algorithm for raising inflight_hi in PROBE_UP.
diff --git a/quiche/quic/core/quic_version_manager.cc b/quiche/quic/core/quic_version_manager.cc
index 2c88477..ec2b9ef 100644
--- a/quiche/quic/core/quic_version_manager.cc
+++ b/quiche/quic/core/quic_version_manager.cc
@@ -38,8 +38,8 @@
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
   static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
-  if (enable_version_2_draft_01_ !=
-          GetQuicReloadableFlag(quic_enable_version_2_draft_01) ||
+  if (enable_version_2_draft_08_ !=
+          GetQuicReloadableFlag(quic_enable_version_2_draft_08) ||
       disable_version_rfcv1_ !=
           GetQuicReloadableFlag(quic_disable_version_rfcv1) ||
       disable_version_draft_29_ !=
@@ -50,8 +50,8 @@
           GetQuicReloadableFlag(quic_disable_version_q046) ||
       disable_version_q043_ !=
           GetQuicReloadableFlag(quic_disable_version_q043)) {
-    enable_version_2_draft_01_ =
-        GetQuicReloadableFlag(quic_enable_version_2_draft_01);
+    enable_version_2_draft_08_ =
+        GetQuicReloadableFlag(quic_enable_version_2_draft_08);
     disable_version_rfcv1_ = GetQuicReloadableFlag(quic_disable_version_rfcv1);
     disable_version_draft_29_ =
         GetQuicReloadableFlag(quic_disable_version_draft_29);
diff --git a/quiche/quic/core/quic_version_manager.h b/quiche/quic/core/quic_version_manager.h
index ddabd1c..c664fc4 100644
--- a/quiche/quic/core/quic_version_manager.h
+++ b/quiche/quic/core/quic_version_manager.h
@@ -55,8 +55,8 @@
 
  private:
   // Cached value of reloadable flags.
-  // quic_enable_version_2_draft_01 flag
-  bool enable_version_2_draft_01_ = false;
+  // quic_enable_version_2_draft_08 flag
+  bool enable_version_2_draft_08_ = false;
   // quic_disable_version_rfcv1 flag
   bool disable_version_rfcv1_ = true;
   // quic_disable_version_draft_29 flag
diff --git a/quiche/quic/core/quic_version_manager_test.cc b/quiche/quic/core/quic_version_manager_test.cc
index 76add7b..3c3a00e 100644
--- a/quiche/quic/core/quic_version_manager_test.cc
+++ b/quiche/quic/core/quic_version_manager_test.cc
@@ -23,7 +23,7 @@
   for (const ParsedQuicVersion& version : AllSupportedVersions()) {
     QuicEnableVersion(version);
   }
-  QuicDisableVersion(ParsedQuicVersion::V2Draft01());
+  QuicDisableVersion(ParsedQuicVersion::V2Draft08());
   QuicDisableVersion(ParsedQuicVersion::RFCv1());
   QuicDisableVersion(ParsedQuicVersion::Draft29());
   QuicVersionManager manager(AllSupportedVersions());
@@ -65,9 +65,9 @@
   EXPECT_THAT(manager.GetSupportedAlpns(),
               ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
 
-  QuicEnableVersion(ParsedQuicVersion::V2Draft01());
+  QuicEnableVersion(ParsedQuicVersion::V2Draft08());
   expected_parsed_versions.insert(expected_parsed_versions.begin(),
-                                  ParsedQuicVersion::V2Draft01());
+                                  ParsedQuicVersion::V2Draft08());
   EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
   EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
             manager.GetSupportedVersions());
diff --git a/quiche/quic/core/quic_versions.cc b/quiche/quic/core/quic_versions.cc
index 89b58b5..70c5549 100644
--- a/quiche/quic/core/quic_versions.cc
+++ b/quiche/quic/core/quic_versions.cc
@@ -40,8 +40,8 @@
                 "Supported versions out of sync");
   const bool enable = should_enable;
   const bool disable = !should_enable;
-  if (version == ParsedQuicVersion::V2Draft01()) {
-    SetQuicReloadableFlag(quic_enable_version_2_draft_01, enable);
+  if (version == ParsedQuicVersion::V2Draft08()) {
+    SetQuicReloadableFlag(quic_enable_version_2_draft_08, enable);
   } else if (version == ParsedQuicVersion::RFCv1()) {
     SetQuicReloadableFlag(quic_disable_version_rfcv1, disable);
   } else if (version == ParsedQuicVersion::Draft29()) {
@@ -180,12 +180,12 @@
 
 bool ParsedQuicVersion::UsesV2PacketTypes() const {
   QUICHE_DCHECK(IsKnown());
-  return transport_version == QUIC_VERSION_IETF_2_DRAFT_01;
+  return transport_version == QUIC_VERSION_IETF_2_DRAFT_08;
 }
 
 bool ParsedQuicVersion::AlpnDeferToRFCv1() const {
   QUICHE_DCHECK(IsKnown());
-  return transport_version == QUIC_VERSION_IETF_2_DRAFT_01;
+  return transport_version == QUIC_VERSION_IETF_2_DRAFT_08;
 }
 
 bool VersionHasLengthPrefixedConnectionIds(
@@ -225,8 +225,8 @@
 QuicVersionLabel CreateQuicVersionLabel(ParsedQuicVersion parsed_version) {
   static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
-  if (parsed_version == ParsedQuicVersion::V2Draft01()) {
-    return MakeVersionLabel(0x70, 0x9a, 0x50, 0xc4);
+  if (parsed_version == ParsedQuicVersion::V2Draft08()) {
+    return MakeVersionLabel(0x6b, 0x33, 0x43, 0xcf);
   } else if (parsed_version == ParsedQuicVersion::RFCv1()) {
     return MakeVersionLabel(0x00, 0x00, 0x00, 0x01);
   } else if (parsed_version == ParsedQuicVersion::Draft29()) {
@@ -429,8 +429,8 @@
   ParsedQuicVersionVector filtered_versions;
   filtered_versions.reserve(versions.size());
   for (const ParsedQuicVersion& version : versions) {
-    if (version == ParsedQuicVersion::V2Draft01()) {
-      if (GetQuicReloadableFlag(quic_enable_version_2_draft_01)) {
+    if (version == ParsedQuicVersion::V2Draft08()) {
+      if (GetQuicReloadableFlag(quic_enable_version_2_draft_08)) {
         filtered_versions.push_back(version);
       }
     } else if (version == ParsedQuicVersion::RFCv1()) {
@@ -519,7 +519,7 @@
     RETURN_STRING_LITERAL(QUIC_VERSION_50);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_29);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_RFC_V1);
-    RETURN_STRING_LITERAL(QUIC_VERSION_IETF_2_DRAFT_01);
+    RETURN_STRING_LITERAL(QUIC_VERSION_IETF_2_DRAFT_08);
     RETURN_STRING_LITERAL(QUIC_VERSION_UNSUPPORTED);
     RETURN_STRING_LITERAL(QUIC_VERSION_RESERVED_FOR_NEGOTIATION);
   }
@@ -542,9 +542,9 @@
                 "Supported versions out of sync");
   if (version == UnsupportedQuicVersion()) {
     return "0";
-  } else if (version == ParsedQuicVersion::V2Draft01()) {
+  } else if (version == ParsedQuicVersion::V2Draft08()) {
     QUICHE_DCHECK(version.UsesHttp3());
-    return "v2draft01";
+    return "V2Draft08";
   } else if (version == ParsedQuicVersion::RFCv1()) {
     QUICHE_DCHECK(version.UsesHttp3());
     return "RFCv1";
@@ -632,7 +632,7 @@
 }
 
 std::string AlpnForVersion(ParsedQuicVersion parsed_version) {
-  if (parsed_version == ParsedQuicVersion::V2Draft01()) {
+  if (parsed_version == ParsedQuicVersion::V2Draft08()) {
     return "h3";
   } else if (parsed_version == ParsedQuicVersion::RFCv1()) {
     return "h3";
diff --git a/quiche/quic/core/quic_versions.h b/quiche/quic/core/quic_versions.h
index 374db5d..883ef5e 100644
--- a/quiche/quic/core/quic_versions.h
+++ b/quiche/quic/core/quic_versions.h
@@ -125,7 +125,7 @@
   // 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,      // RFC 9000.
-  QUIC_VERSION_IETF_2_DRAFT_01 = 81,  // draft-ietf-quic-v2-01.
+  QUIC_VERSION_IETF_2_DRAFT_08 = 81,  // draft-ietf-quic-v2-08.
   // Version 99 was a dumping ground for IETF QUIC changes which were not yet
   // ready for production between 2018-02 and 2020-02.
 
@@ -173,7 +173,7 @@
     QuicTransportVersion transport_version) {
   bool transport_version_is_valid = false;
   constexpr QuicTransportVersion valid_transport_versions[] = {
-      QUIC_VERSION_IETF_2_DRAFT_01,
+      QUIC_VERSION_IETF_2_DRAFT_08,
       QUIC_VERSION_IETF_RFC_V1,
       QUIC_VERSION_IETF_DRAFT_29,
       QUIC_VERSION_50,
@@ -199,7 +199,7 @@
              transport_version != QUIC_VERSION_RESERVED_FOR_NEGOTIATION &&
              transport_version != QUIC_VERSION_IETF_DRAFT_29 &&
              transport_version != QUIC_VERSION_IETF_RFC_V1 &&
-             transport_version != QUIC_VERSION_IETF_2_DRAFT_01;
+             transport_version != QUIC_VERSION_IETF_2_DRAFT_08;
     case PROTOCOL_TLS1_3:
       return transport_version != QUIC_VERSION_UNSUPPORTED &&
              transport_version != QUIC_VERSION_50 &&
@@ -249,8 +249,8 @@
            transport_version != other.transport_version;
   }
 
-  static constexpr ParsedQuicVersion V2Draft01() {
-    return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_2_DRAFT_01);
+  static constexpr ParsedQuicVersion V2Draft08() {
+    return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_2_DRAFT_08);
   }
 
   static constexpr ParsedQuicVersion RFCv1() {
@@ -411,7 +411,7 @@
 
 constexpr std::array<ParsedQuicVersion, 6> SupportedVersions() {
   return {
-      ParsedQuicVersion::V2Draft01(), ParsedQuicVersion::RFCv1(),
+      ParsedQuicVersion::V2Draft08(), ParsedQuicVersion::RFCv1(),
       ParsedQuicVersion::Draft29(),   ParsedQuicVersion::Q050(),
       ParsedQuicVersion::Q046(),      ParsedQuicVersion::Q043(),
   };
diff --git a/quiche/quic/core/quic_versions_test.cc b/quiche/quic/core/quic_versions_test.cc
index ff57f3f..30cbcf7 100644
--- a/quiche/quic/core/quic_versions_test.cc
+++ b/quiche/quic/core/quic_versions_test.cc
@@ -114,13 +114,13 @@
             ParseQuicVersionLabel(MakeVersionLabel(0xff, 0x00, 0x00, 0x1d)));
   EXPECT_EQ(ParsedQuicVersion::RFCv1(),
             ParseQuicVersionLabel(MakeVersionLabel(0x00, 0x00, 0x00, 0x01)));
-  EXPECT_EQ(ParsedQuicVersion::V2Draft01(),
-            ParseQuicVersionLabel(MakeVersionLabel(0x70, 0x9a, 0x50, 0xc4)));
-  EXPECT_EQ((ParsedQuicVersionVector{ParsedQuicVersion::V2Draft01(),
+  EXPECT_EQ(ParsedQuicVersion::V2Draft08(),
+            ParseQuicVersionLabel(MakeVersionLabel(0x6b, 0x33, 0x43, 0xcf)));
+  EXPECT_EQ((ParsedQuicVersionVector{ParsedQuicVersion::V2Draft08(),
                                      ParsedQuicVersion::RFCv1(),
                                      ParsedQuicVersion::Draft29()}),
             ParseQuicVersionLabelVector(QuicVersionLabelVector{
-                MakeVersionLabel(0x70, 0x9a, 0x50, 0xc4),
+                MakeVersionLabel(0x6b, 0x33, 0x43, 0xcf),
                 MakeVersionLabel(0x00, 0x00, 0x00, 0x01),
                 MakeVersionLabel(0xaa, 0xaa, 0xaa, 0xaa),
                 MakeVersionLabel(0xff, 0x00, 0x00, 0x1d)}));
@@ -231,8 +231,8 @@
   EXPECT_EQ(0x51303530u, CreateQuicVersionLabel(ParsedQuicVersion::Q050()));
   EXPECT_EQ(0xff00001du, CreateQuicVersionLabel(ParsedQuicVersion::Draft29()));
   EXPECT_EQ(0x00000001u, CreateQuicVersionLabel(ParsedQuicVersion::RFCv1()));
-  EXPECT_EQ(0x709a50c4u,
-            CreateQuicVersionLabel(ParsedQuicVersion::V2Draft01()));
+  EXPECT_EQ(0x6b3343cfu,
+            CreateQuicVersionLabel(ParsedQuicVersion::V2Draft08()));
 
   // Make sure the negotiation reserved version is in the IETF reserved space.
   EXPECT_EQ(
@@ -259,8 +259,8 @@
                             ParsedQuicVersion::Draft29())));
   EXPECT_EQ("00000001", QuicVersionLabelToString(CreateQuicVersionLabel(
                             ParsedQuicVersion::RFCv1())));
-  EXPECT_EQ("709a50c4", QuicVersionLabelToString(CreateQuicVersionLabel(
-                            ParsedQuicVersion::V2Draft01())));
+  EXPECT_EQ("6b3343cf", QuicVersionLabelToString(CreateQuicVersionLabel(
+                            ParsedQuicVersion::V2Draft08())));
 
   QuicVersionLabelVector version_labels = {
       MakeVersionLabel('Q', '0', '3', '5'),
@@ -295,8 +295,8 @@
             ParseQuicVersionLabelString("ff00001d"));
   EXPECT_EQ(ParsedQuicVersion::RFCv1(),
             ParseQuicVersionLabelString("00000001"));
-  EXPECT_EQ(ParsedQuicVersion::V2Draft01(),
-            ParseQuicVersionLabelString("709a50c4"));
+  EXPECT_EQ(ParsedQuicVersion::V2Draft08(),
+            ParseQuicVersionLabelString("6b3343cf"));
 
   // Sanity check that a variety of other serialization formats are ignored.
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionLabelString("1"));
@@ -353,8 +353,8 @@
   EXPECT_EQ("Q050", ParsedQuicVersionToString(ParsedQuicVersion::Q050()));
   EXPECT_EQ("draft29", ParsedQuicVersionToString(ParsedQuicVersion::Draft29()));
   EXPECT_EQ("RFCv1", ParsedQuicVersionToString(ParsedQuicVersion::RFCv1()));
-  EXPECT_EQ("v2draft01",
-            ParsedQuicVersionToString(ParsedQuicVersion::V2Draft01()));
+  EXPECT_EQ("V2Draft08",
+            ParsedQuicVersionToString(ParsedQuicVersion::V2Draft08()));
 
   ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q043()};
   EXPECT_EQ("Q043", ParsedQuicVersionVectorToString(versions_vector));
@@ -428,7 +428,7 @@
   EXPECT_EQ(QUIC_VERSION_50, 50);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_29, 73);
   EXPECT_EQ(QUIC_VERSION_IETF_RFC_V1, 80);
-  EXPECT_EQ(QUIC_VERSION_IETF_2_DRAFT_01, 81);
+  EXPECT_EQ(QUIC_VERSION_IETF_2_DRAFT_08, 81);
 }
 
 TEST(QuicVersionsTest, AlpnForVersion) {
@@ -439,7 +439,7 @@
   EXPECT_EQ("h3-Q050", AlpnForVersion(ParsedQuicVersion::Q050()));
   EXPECT_EQ("h3-29", AlpnForVersion(ParsedQuicVersion::Draft29()));
   EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::RFCv1()));
-  EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::V2Draft01()));
+  EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::V2Draft08()));
 }
 
 TEST(QuicVersionsTest, QuicVersionEnabling) {
@@ -490,7 +490,7 @@
                 CreateQuicVersionLabel(version2))
           << version1 << " " << version2;
       // The one pair where ALPNs are the same.
-      if ((version1 != ParsedQuicVersion::V2Draft01()) &&
+      if ((version1 != ParsedQuicVersion::V2Draft08()) &&
           (version2 != ParsedQuicVersion::RFCv1())) {
         EXPECT_NE(AlpnForVersion(version1), AlpnForVersion(version2))
             << version1 << " " << version2;