diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index 5cc4d36..3216ea8 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -103,7 +103,10 @@
     config_.set_enable_serving_sct(true);
 
     client_version_ = supported_versions_.front();
-    client_version_string_ = ParsedQuicVersionToString(client_version_);
+    client_version_label_ = CreateQuicVersionLabel(client_version_);
+    client_version_string_ =
+        std::string(reinterpret_cast<const char*>(&client_version_label_),
+                    sizeof(client_version_label_));
   }
 
   void SetUp() override {
@@ -265,7 +268,6 @@
       } else {
         ASSERT_NE(error, QUIC_NO_ERROR)
             << "Message didn't fail: " << result_->client_hello.DebugString();
-
         EXPECT_TRUE(error_details.find(error_substr_) != std::string::npos)
             << error_substr_ << " not in " << error_details;
       }
@@ -341,6 +343,7 @@
   QuicSocketAddress client_address_;
   ParsedQuicVersionVector supported_versions_;
   ParsedQuicVersion client_version_;
+  QuicVersionLabel client_version_label_;
   std::string client_version_string_;
   QuicCryptoServerConfig config_;
   QuicCryptoServerConfigPeer peer_;
@@ -497,9 +500,8 @@
 
 TEST_P(CryptoServerTest, TooSmall) {
   ShouldFailMentioning(
-      "too small",
-      crypto_test_utils::CreateCHLO(
-          {{"PDMD", "X509"}, {"VER\0", client_version_string_.c_str()}}));
+      "too small", crypto_test_utils::CreateCHLO(
+                       {{"PDMD", "X509"}, {"VER\0", client_version_string_}}));
 
   const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 085a65a..642799e 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -88,6 +88,8 @@
 
 namespace {
 
+static_assert(kQuicIetfDraftVersion == 22, "Salts do not match draft version");
+// Salt from https://tools.ietf.org/html/draft-ietf-quic-tls-22#section-5.2
 const uint8_t kInitialSalt[] = {0x7f, 0xbc, 0xdb, 0x0e, 0x7c, 0x66, 0xbb,
                                 0xe9, 0x19, 0x3a, 0x96, 0xcd, 0x21, 0x51,
                                 0x9e, 0xbd, 0x7a, 0x02, 0x64, 0x4a};
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 9aab379..3a6d514 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -939,7 +939,7 @@
     ASSERT_TRUE(Initialize());
     return;
   }
-  QuicVersionInitializeSupportForIetfDraft(1);
+  QuicVersionInitializeSupportForIetfDraft();
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index ce040f2..b13f7e1 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -605,21 +605,9 @@
   }
 
   // Helper function to get unsigned char representation of the handshake
-  // protocol byte of the current QUIC version number.
-  unsigned char GetQuicVersionProtocolByte() {
-    return (CreateQuicVersionLabel(version_) >> 24) & 0xff;
-  }
-
-  // Helper function to get unsigned char representation of digit in the
-  // units place of the current QUIC version number.
-  unsigned char GetQuicVersionDigitOnes() {
-    return CreateQuicVersionLabel(version_) & 0xff;
-  }
-
-  // Helper function to get unsigned char representation of digit in the
-  // tens place of the current QUIC version number.
-  unsigned char GetQuicVersionDigitTens() {
-    return (CreateQuicVersionLabel(version_) >> 8) & 0xff;
+  // protocol byte at position |pos| of the current QUIC version number.
+  unsigned char GetQuicVersionByte(int pos) {
+    return (CreateQuicVersionLabel(version_) >> 8 * (3 - pos)) & 0xff;
   }
 
   bool CheckEncryption(QuicPacketNumber packet_number, QuicPacket* packet) {
@@ -818,9 +806,9 @@
 // testing, and these byte arrays contain the QUIC version. This macro explodes
 // the 32-bit version into four bytes in network order. Since it uses methods of
 // QuicFramerTest, it is only valid to use this in a QuicFramerTest.
-#define QUIC_VERSION_BYTES                                      \
-  GetQuicVersionProtocolByte(), '0', GetQuicVersionDigitTens(), \
-      GetQuicVersionDigitOnes()
+#define QUIC_VERSION_BYTES                                             \
+  GetQuicVersionByte(0), GetQuicVersionByte(1), GetQuicVersionByte(2), \
+      GetQuicVersionByte(3)
 
 // Run all framer tests with all supported versions of QUIC.
 INSTANTIATE_TEST_SUITE_P(QuicFramerTests,
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 3808e95..8281b68 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -120,10 +120,8 @@
     case QUIC_VERSION_48:
       return MakeVersionLabel(proto, '0', '4', '8');
     case QUIC_VERSION_99:
-      if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3 &&
-          GetQuicFlag(FLAGS_quic_ietf_draft_version) != 0) {
-        return MakeVersionLabel(0xff, 0x00, 0x00,
-                                GetQuicFlag(FLAGS_quic_ietf_draft_version));
+      if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3) {
+        return MakeVersionLabel(0xff, 0x00, 0x00, kQuicIetfDraftVersion);
       }
       return MakeVersionLabel(proto, '0', '9', '9');
     case QUIC_VERSION_RESERVED_FOR_NEGOTIATION:
@@ -449,26 +447,13 @@
 
 std::string AlpnForVersion(ParsedQuicVersion parsed_version) {
   if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3 &&
-      parsed_version.transport_version == QUIC_VERSION_99 &&
-      GetQuicFlag(FLAGS_quic_ietf_draft_version) != 0) {
-    return "h3-" + QuicTextUtils::Uint64ToString(
-                       GetQuicFlag(FLAGS_quic_ietf_draft_version));
+      parsed_version.transport_version == QUIC_VERSION_99) {
+    return "h3-" + QuicTextUtils::Uint64ToString(kQuicIetfDraftVersion);
   }
   return "h3-" + ParsedQuicVersionToString(parsed_version);
 }
 
-void QuicVersionInitializeSupportForIetfDraft(int32_t draft_version) {
-  if (draft_version < 0 || draft_version >= 256) {
-    QUIC_LOG(FATAL) << "Invalid IETF draft version " << draft_version;
-    return;
-  }
-
-  SetQuicFlag(FLAGS_quic_ietf_draft_version, draft_version);
-
-  if (draft_version == 0) {
-    return;
-  }
-
+void QuicVersionInitializeSupportForIetfDraft() {
   // Enable necessary flags.
   SetQuicFlag(FLAGS_quic_supports_tls_handshake, true);
   SetQuicReloadableFlag(quic_simplify_stop_waiting, true);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 2702c60..5b2a6ed 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -116,6 +116,9 @@
   QUIC_VERSION_RESERVED_FOR_NEGOTIATION = 999,
 };
 
+// IETF draft version most closely approximated by TLS + v99.
+static const int kQuicIetfDraftVersion = 22;
+
 // The crypto handshake protocols that can be used with QUIC.
 enum HandshakeProtocol {
   PROTOCOL_UNSUPPORTED,
@@ -439,10 +442,9 @@
 QUIC_EXPORT_PRIVATE std::string AlpnForVersion(
     ParsedQuicVersion parsed_version);
 
-// Initializes support for the provided IETF draft version by setting flags
-// and the version label.
-QUIC_EXPORT_PRIVATE void QuicVersionInitializeSupportForIetfDraft(
-    int32_t draft_version);
+// Initializes support for the provided IETF draft version by setting the
+// correct flags.
+QUIC_EXPORT_PRIVATE void QuicVersionInitializeSupportForIetfDraft();
 
 // Enables the flags required to support this version of QUIC.
 QUIC_EXPORT_PRIVATE void QuicEnableVersion(ParsedQuicVersion parsed_version);
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index 09d6a3e..f5b0dd2 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -469,32 +469,7 @@
   EXPECT_EQ("h3-T047", AlpnForVersion(parsed_version_t047));
   EXPECT_EQ("h3-Q048", AlpnForVersion(parsed_version_q048));
   EXPECT_EQ("h3-T048", AlpnForVersion(parsed_version_t048));
-  EXPECT_EQ("h3-T099", AlpnForVersion(parsed_version_t099));
-}
-
-TEST_F(QuicVersionsTest, InitializeSupportForIetfDraft) {
-  ParsedQuicVersion parsed_version_t099 =
-      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
-  EXPECT_EQ(MakeVersionLabel('T', '0', '9', '9'),
-            CreateQuicVersionLabel(parsed_version_t099));
-  EXPECT_EQ("h3-T099", AlpnForVersion(parsed_version_t099));
-
-  QuicVersionInitializeSupportForIetfDraft(0);
-  EXPECT_EQ(MakeVersionLabel('T', '0', '9', '9'),
-            CreateQuicVersionLabel(parsed_version_t099));
-  EXPECT_EQ("h3-T099", AlpnForVersion(parsed_version_t099));
-  EXPECT_FALSE(GetQuicFlag(FLAGS_quic_supports_tls_handshake));
-
-  QuicVersionInitializeSupportForIetfDraft(18);
-  EXPECT_TRUE(GetQuicFlag(FLAGS_quic_supports_tls_handshake));
-  EXPECT_EQ(MakeVersionLabel(0xff, 0, 0, 18),
-            CreateQuicVersionLabel(parsed_version_t099));
-  EXPECT_EQ("h3-18", AlpnForVersion(parsed_version_t099));
-
-  QuicVersionInitializeSupportForIetfDraft(0);
-  EXPECT_EQ(MakeVersionLabel('T', '0', '9', '9'),
-            CreateQuicVersionLabel(parsed_version_t099));
-  EXPECT_EQ("h3-T099", AlpnForVersion(parsed_version_t099));
+  EXPECT_EQ("h3-22", AlpnForVersion(parsed_version_t099));
 }
 
 TEST_F(QuicVersionsTest, QuicEnableVersion) {
diff --git a/quic/tools/quic_client_interop_test_bin.cc b/quic/tools/quic_client_interop_test_bin.cc
index d972678..39f8ff9 100644
--- a/quic/tools/quic_client_interop_test_bin.cc
+++ b/quic/tools/quic_client_interop_test_bin.cc
@@ -19,14 +19,6 @@
 
 DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t, port, 0, "The port to connect to.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    int32_t,
-    quic_ietf_draft,
-    0,
-    "QUIC IETF draft number to use over the wire, e.g. 18. "
-    "By default this sets quic_version to T099. "
-    "This also enables required internal QUIC flags.");
-
 namespace quic {
 
 enum class Feature {
@@ -118,11 +110,9 @@
   return features;
 }
 
-std::set<Feature> ServerSupport(std::string host,
-                                int port,
-                                int32_t ietf_draft) {
+std::set<Feature> ServerSupport(std::string host, int port) {
   // Configure version list.
-  QuicVersionInitializeSupportForIetfDraft(ietf_draft);
+  QuicVersionInitializeSupportForIetfDraft();
   ParsedQuicVersion version =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
   ParsedQuicVersionVector versions = {version};
@@ -160,13 +150,12 @@
   }
   std::string host = GetQuicFlag(FLAGS_host);
   int port = GetQuicFlag(FLAGS_port);
-  const int32_t quic_ietf_draft = GetQuicFlag(FLAGS_quic_ietf_draft);
-  if (host.empty() || port == 0 || quic_ietf_draft == 0) {
+  if (host.empty() || port == 0) {
     quic::QuicPrintCommandLineFlagHelp(usage);
     exit(1);
   }
 
-  auto supported_features = quic::ServerSupport(host, port, quic_ietf_draft);
+  auto supported_features = quic::ServerSupport(host, port);
   std::cout << "Supported features: ";
   for (auto feature : supported_features) {
     std::cout << MatrixLetter(feature);
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index ed05600..09e7a50 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -111,13 +111,11 @@
     "versions are offered in the handshake. Also supports wire versions "
     "such as Q043 or T099.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    int32_t,
-    quic_ietf_draft,
-    0,
-    "QUIC IETF draft number to use over the wire, e.g. 18. "
-    "By default this sets quic_version to T099. "
-    "This also enables required internal QUIC flags.");
+DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
+                              quic_ietf_draft,
+                              false,
+                              "Use the IETF draft version. This also enables "
+                              "required internal QUIC flags.");
 
 DEFINE_QUIC_COMMAND_LINE_FLAG(
     bool,
@@ -183,14 +181,12 @@
   quic::ParsedQuicVersionVector versions = quic::CurrentSupportedVersions();
 
   std::string quic_version_string = GetQuicFlag(FLAGS_quic_version);
-  const int32_t quic_ietf_draft = GetQuicFlag(FLAGS_quic_ietf_draft);
-  if (quic_ietf_draft > 0) {
-    quic::QuicVersionInitializeSupportForIetfDraft(quic_ietf_draft);
-    if (quic_version_string.length() == 0) {
-      quic_version_string = "T099";
-    }
-  }
-  if (quic_version_string.length() > 0) {
+  if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
+    quic::QuicVersionInitializeSupportForIetfDraft();
+    versions = {{quic::PROTOCOL_TLS1_3, quic::QUIC_VERSION_99}};
+    quic::QuicEnableVersion(versions[0]);
+
+  } else if (!quic_version_string.empty()) {
     if (quic_version_string[0] == 'T') {
       // ParseQuicVersionString checks quic_supports_tls_handshake.
       SetQuicFlag(FLAGS_quic_supports_tls_handshake, true);
@@ -201,8 +197,7 @@
         quic::QUIC_VERSION_UNSUPPORTED) {
       return 1;
     }
-    versions.clear();
-    versions.push_back(parsed_quic_version);
+    versions = {parsed_quic_version};
     quic::QuicEnableVersion(parsed_quic_version);
   }
 
diff --git a/quic/tools/quic_toy_server.cc b/quic/tools/quic_toy_server.cc
index 633b465..9fb15eb 100644
--- a/quic/tools/quic_toy_server.cc
+++ b/quic/tools/quic_toy_server.cc
@@ -26,12 +26,11 @@
     "construction to seed the cache. Cache directory can be "
     "generated using `wget -p --save-headers <url>`");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    int32_t,
-    quic_ietf_draft,
-    0,
-    "QUIC IETF draft number to use over the wire, e.g. 18. "
-    "This also enables required internal QUIC flags.");
+DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
+                              quic_ietf_draft,
+                              false,
+                              "Use the IETF draft version. This also enables "
+                              "required internal QUIC flags.");
 
 namespace quic {
 
@@ -50,9 +49,8 @@
     : backend_factory_(backend_factory), server_factory_(server_factory) {}
 
 int QuicToyServer::Start() {
-  const int32_t quic_ietf_draft = GetQuicFlag(FLAGS_quic_ietf_draft);
-  if (quic_ietf_draft > 0) {
-    quic::QuicVersionInitializeSupportForIetfDraft(quic_ietf_draft);
+  if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
+    QuicVersionInitializeSupportForIetfDraft();
     quic::QuicEnableVersion(
         quic::ParsedQuicVersion(quic::PROTOCOL_TLS1_3, quic::QUIC_VERSION_99));
   }