diff --git a/ackhandler/interfaces.go b/ackhandler/interfaces.go
index 8070b050..b209b587 100644
--- a/ackhandler/interfaces.go
+++ b/ackhandler/interfaces.go
@@ -28,8 +28,7 @@ type SentPacketHandler interface {
 
 // ReceivedPacketHandler handles ACKs needed to send for incoming packets
 type ReceivedPacketHandler interface {
-	// TODO: remove entroypyBit once we drop support for QUIC 33
-	ReceivedPacket(packetNumber protocol.PacketNumber, entropyBit bool) error
+	ReceivedPacket(packetNumber protocol.PacketNumber) error
 	ReceivedStopWaiting(*frames.StopWaitingFrame) error
 
 	GetAckFrame(dequeue bool) (*frames.AckFrame, error)
diff --git a/ackhandler/received_packet_handler.go b/ackhandler/received_packet_handler.go
index 112c079d..7416ed88 100644
--- a/ackhandler/received_packet_handler.go
+++ b/ackhandler/received_packet_handler.go
@@ -44,7 +44,7 @@ func NewReceivedPacketHandler() ReceivedPacketHandler {
 	}
 }
 
-func (h *receivedPacketHandler) ReceivedPacket(packetNumber protocol.PacketNumber, entropyBit bool) error {
+func (h *receivedPacketHandler) ReceivedPacket(packetNumber protocol.PacketNumber) error {
 	if packetNumber == 0 {
 		return errInvalidPacketNumber
 	}
diff --git a/ackhandler/received_packet_handler_test.go b/ackhandler/received_packet_handler_test.go
index 1c3c0937..5e55d9e5 100644
--- a/ackhandler/received_packet_handler_test.go
+++ b/ackhandler/received_packet_handler_test.go
@@ -21,62 +21,62 @@ var _ = Describe("receivedPacketHandler", func() {
 
 	Context("accepting packets", func() {
 		It("handles a packet that arrives late", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(1), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(1))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.receivedTimes).To(HaveKey(protocol.PacketNumber(1)))
-			err = handler.ReceivedPacket(protocol.PacketNumber(3), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(3))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.receivedTimes).To(HaveKey(protocol.PacketNumber(3)))
-			err = handler.ReceivedPacket(protocol.PacketNumber(2), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(2))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.receivedTimes).To(HaveKey(protocol.PacketNumber(2)))
 		})
 
 		It("rejects packets with packet number 0", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(0), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(0))
 			Expect(err).To(MatchError(errInvalidPacketNumber))
 		})
 
 		It("rejects a duplicate package with PacketNumber equal to LargestObserved", func() {
 			for i := 1; i < 5; i++ {
-				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+				err := handler.ReceivedPacket(protocol.PacketNumber(i))
 				Expect(err).ToNot(HaveOccurred())
 			}
-			err := handler.ReceivedPacket(4, false)
+			err := handler.ReceivedPacket(4)
 			Expect(err).To(MatchError(ErrDuplicatePacket))
 		})
 
 		It("rejects a duplicate package with PacketNumber less than the LargestObserved", func() {
 			for i := 1; i < 5; i++ {
-				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+				err := handler.ReceivedPacket(protocol.PacketNumber(i))
 				Expect(err).ToNot(HaveOccurred())
 			}
-			err := handler.ReceivedPacket(2, false)
+			err := handler.ReceivedPacket(2)
 			Expect(err).To(MatchError(ErrDuplicatePacket))
 		})
 
 		It("ignores a packet with PacketNumber less than the LeastUnacked of a previously received StopWaiting", func() {
-			err := handler.ReceivedPacket(5, false)
+			err := handler.ReceivedPacket(5)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: 10})
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(9, false)
+			err = handler.ReceivedPacket(9)
 			Expect(err).To(MatchError(ErrPacketSmallerThanLastStopWaiting))
 			Expect(handler.largestInOrderObserved).To(Equal(protocol.PacketNumber(9)))
 		})
 
 		It("does not ignore a packet with PacketNumber equal to LeastUnacked of a previously received StopWaiting", func() {
-			err := handler.ReceivedPacket(5, false)
+			err := handler.ReceivedPacket(5)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: 10})
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(10, false)
+			err = handler.ReceivedPacket(10)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.largestInOrderObserved).To(Equal(protocol.PacketNumber(10)))
 		})
 
 		It("saves the time when each packet arrived", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(3), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(3))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.receivedTimes).To(HaveKey(protocol.PacketNumber(3)))
 			Expect(handler.receivedTimes[3]).To(BeTemporally("~", time.Now(), 10*time.Millisecond))
@@ -85,10 +85,10 @@ var _ = Describe("receivedPacketHandler", func() {
 		It("doesn't store more than MaxTrackedReceivedPackets packets", func() {
 			for i := uint32(0); i < protocol.MaxTrackedReceivedPackets; i++ {
 				packetNumber := protocol.PacketNumber(1 + 2*i)
-				err := handler.ReceivedPacket(packetNumber, false)
+				err := handler.ReceivedPacket(packetNumber)
 				Expect(err).ToNot(HaveOccurred())
 			}
-			err := handler.ReceivedPacket(protocol.PacketNumber(3*protocol.MaxTrackedReceivedPackets), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(3 * protocol.MaxTrackedReceivedPackets))
 			Expect(err).To(MatchError(errTooManyOutstandingReceivedPackets))
 		})
 	})
@@ -100,7 +100,7 @@ var _ = Describe("receivedPacketHandler", func() {
 				if i == 10 || i == 11 || i == 12 {
 					continue
 				}
-				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+				err := handler.ReceivedPacket(protocol.PacketNumber(i))
 				Expect(err).ToNot(HaveOccurred())
 			}
 			err := handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: protocol.PacketNumber(12)})
@@ -116,7 +116,7 @@ var _ = Describe("receivedPacketHandler", func() {
 
 		It("increase the ignorePacketsBelow number, even if all packets below the LeastUnacked were already acked", func() {
 			for i := 1; i < 20; i++ {
-				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+				err := handler.ReceivedPacket(protocol.PacketNumber(i))
 				Expect(err).ToNot(HaveOccurred())
 			}
 			Expect(handler.largestInOrderObserved).To(Equal(protocol.PacketNumber(19)))
@@ -137,9 +137,9 @@ var _ = Describe("receivedPacketHandler", func() {
 
 	Context("ACK package generation", func() {
 		It("generates a simple ACK frame", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(1), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(1))
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(protocol.PacketNumber(2), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(2))
 			Expect(err).ToNot(HaveOccurred())
 			ack, err := handler.GetAckFrame(true)
 			Expect(err).ToNot(HaveOccurred())
@@ -149,9 +149,9 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("generates an ACK frame with missing packets", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(1), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(1))
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(protocol.PacketNumber(4), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(4))
 			Expect(err).ToNot(HaveOccurred())
 			ack, err := handler.GetAckFrame(true)
 			Expect(err).ToNot(HaveOccurred())
@@ -163,9 +163,9 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("does not generate an ACK if an ACK has already been sent for the largest Packet", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(1), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(1))
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(protocol.PacketNumber(2), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(2))
 			Expect(err).ToNot(HaveOccurred())
 			ack, err := handler.GetAckFrame(true)
 			Expect(err).ToNot(HaveOccurred())
@@ -176,7 +176,7 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("does not dequeue an ACK frame if told so", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(2), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(2))
 			Expect(err).ToNot(HaveOccurred())
 			ack, err := handler.GetAckFrame(false)
 			Expect(err).ToNot(HaveOccurred())
@@ -190,7 +190,7 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("returns a cached ACK frame if the ACK was not dequeued", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(2), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(2))
 			Expect(err).ToNot(HaveOccurred())
 			ack, err := handler.GetAckFrame(false)
 			Expect(err).ToNot(HaveOccurred())
@@ -202,12 +202,12 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("generates a new ACK (and deletes the cached one) when a new packet arrives", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(1), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(1))
 			Expect(err).ToNot(HaveOccurred())
 			ack, _ := handler.GetAckFrame(true)
 			Expect(ack).ToNot(BeNil())
 			Expect(ack.LargestAcked).To(Equal(protocol.PacketNumber(1)))
-			err = handler.ReceivedPacket(protocol.PacketNumber(3), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(3))
 			Expect(err).ToNot(HaveOccurred())
 			ack, _ = handler.GetAckFrame(true)
 			Expect(ack).ToNot(BeNil())
@@ -215,14 +215,14 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("generates a new ACK when an out-of-order packet arrives", func() {
-			err := handler.ReceivedPacket(protocol.PacketNumber(1), false)
+			err := handler.ReceivedPacket(protocol.PacketNumber(1))
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(protocol.PacketNumber(3), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(3))
 			Expect(err).ToNot(HaveOccurred())
 			ack, _ := handler.GetAckFrame(true)
 			Expect(ack).ToNot(BeNil())
 			Expect(ack.AckRanges).To(HaveLen(2))
-			err = handler.ReceivedPacket(protocol.PacketNumber(2), false)
+			err = handler.ReceivedPacket(protocol.PacketNumber(2))
 			Expect(err).ToNot(HaveOccurred())
 			ack, _ = handler.GetAckFrame(true)
 			Expect(ack).ToNot(BeNil())
@@ -230,13 +230,13 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("doesn't send old ACK ranges after receiving a StopWaiting", func() {
-			err := handler.ReceivedPacket(5, false)
+			err := handler.ReceivedPacket(5)
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(10, false)
+			err = handler.ReceivedPacket(10)
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(11, false)
+			err = handler.ReceivedPacket(11)
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(12, false)
+			err = handler.ReceivedPacket(12)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: protocol.PacketNumber(11)})
 			Expect(err).ToNot(HaveOccurred())
@@ -250,7 +250,7 @@ var _ = Describe("receivedPacketHandler", func() {
 
 		It("deletes packets from the packetHistory after receiving a StopWaiting, after continuously received packets", func() {
 			for i := 1; i <= 12; i++ {
-				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+				err := handler.ReceivedPacket(protocol.PacketNumber(i))
 				Expect(err).ToNot(HaveOccurred())
 			}
 			err := handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: protocol.PacketNumber(6)})
@@ -269,7 +269,7 @@ var _ = Describe("receivedPacketHandler", func() {
 	Context("Garbage Collector", func() {
 		It("garbage collects receivedTimes after receiving a StopWaiting, if there are no missing packets", func() {
 			for i := 1; i <= 4; i++ {
-				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+				err := handler.ReceivedPacket(protocol.PacketNumber(i))
 				Expect(err).ToNot(HaveOccurred())
 			}
 			err := handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: 3})
@@ -283,7 +283,7 @@ var _ = Describe("receivedPacketHandler", func() {
 
 		It("garbage collects the receivedTimes after receiving multiple StopWaitings", func() {
 			for i := 1; i <= 9; i++ {
-				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+				err := handler.ReceivedPacket(protocol.PacketNumber(i))
 				Expect(err).ToNot(HaveOccurred())
 			}
 			err := handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: 4})
@@ -297,11 +297,11 @@ var _ = Describe("receivedPacketHandler", func() {
 		})
 
 		It("garbage collects receivedTimes after receiving a StopWaiting, if there are missing packets", func() {
-			err := handler.ReceivedPacket(1, false)
+			err := handler.ReceivedPacket(1)
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(2, false)
+			err = handler.ReceivedPacket(2)
 			Expect(err).ToNot(HaveOccurred())
-			err = handler.ReceivedPacket(4, false)
+			err = handler.ReceivedPacket(4)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: 4})
 			Expect(err).ToNot(HaveOccurred())
diff --git a/packet_unpacker.go b/packet_unpacker.go
index 13c773c7..56e8ae67 100644
--- a/packet_unpacker.go
+++ b/packet_unpacker.go
@@ -12,8 +12,7 @@ import (
 )
 
 type unpackedPacket struct {
-	entropyBit bool
-	frames     []frames.Frame
+	frames []frames.Frame
 }
 
 type packetUnpacker struct {
@@ -31,17 +30,6 @@ func (u *packetUnpacker) Unpack(publicHeaderBinary []byte, hdr *PublicHeader, da
 	}
 	r := bytes.NewReader(decrypted)
 
-	// read private flag byte, for QUIC Version < 34
-	var entropyBit bool
-	if u.version < protocol.Version34 {
-		var privateFlag uint8
-		privateFlag, err = r.ReadByte()
-		if err != nil {
-			return nil, qerr.MissingPayload
-		}
-		entropyBit = privateFlag&0x01 > 0
-	}
-
 	if r.Len() == 0 {
 		return nil, qerr.MissingPayload
 	}
@@ -117,7 +105,6 @@ ReadLoop:
 	}
 
 	return &unpackedPacket{
-		entropyBit: entropyBit,
-		frames:     fs,
+		frames: fs,
 	}, nil
 }
diff --git a/packet_unpacker_test.go b/packet_unpacker_test.go
index 08fecfaa..f98a34ae 100644
--- a/packet_unpacker_test.go
+++ b/packet_unpacker_test.go
@@ -35,29 +35,10 @@ var _ = Describe("Packet unpacker", func() {
 	})
 
 	setData := func(p []byte) {
-		if unpacker.version < protocol.Version34 { // add private flag
-			p = append([]byte{0x01}, p...)
-		}
 		data = aead.Seal(nil, p, 0, hdrBin)
 	}
 
-	It("returns an error for empty packets that don't have a private flag, for QUIC Version < 34", func() {
-		unpacker.version = protocol.Version34
-		setData(nil)
-		unpacker.version = protocol.Version33
-		_, err := unpacker.Unpack(hdrBin, hdr, data)
-		Expect(err).To(MatchError(qerr.MissingPayload))
-	})
-
-	It("returns an error for empty packets that have a private flag, for QUIC Version < 34", func() {
-		unpacker.version = protocol.Version33
-		setData(nil)
-		_, err := unpacker.Unpack(hdrBin, hdr, data)
-		Expect(err).To(MatchError(qerr.MissingPayload))
-	})
-
 	It("does not read read a private flag for QUIC Version >= 34", func() {
-		unpacker.version = protocol.Version34
 		f := &frames.ConnectionCloseFrame{ReasonPhrase: "foo"}
 		err := f.Write(buf, 0)
 		Expect(err).ToNot(HaveOccurred())
diff --git a/session.go b/session.go
index 4d5c26e3..f9490369 100644
--- a/session.go
+++ b/session.go
@@ -253,7 +253,7 @@ func (s *Session) handlePacketImpl(remoteAddr interface{}, hdr *PublicHeader, da
 	// Only do this after decrypting, so we are sure the packet is not attacker-controlled
 	s.largestRcvdPacketNumber = utils.MaxPacketNumber(s.largestRcvdPacketNumber, hdr.PacketNumber)
 
-	err = s.receivedPacketHandler.ReceivedPacket(hdr.PacketNumber, packet.entropyBit)
+	err = s.receivedPacketHandler.ReceivedPacket(hdr.PacketNumber)
 	// ignore duplicate packets
 	if err == ackhandler.ErrDuplicatePacket {
 		utils.Infof("Ignoring packet 0x%x due to ErrDuplicatePacket", hdr.PacketNumber)
diff --git a/session_test.go b/session_test.go
index 70d5810b..a2a10d38 100644
--- a/session_test.go
+++ b/session_test.go
@@ -42,8 +42,7 @@ type mockUnpacker struct{}
 
 func (m *mockUnpacker) Unpack(publicHeaderBinary []byte, hdr *PublicHeader, data []byte) (*unpackedPacket, error) {
 	return &unpackedPacket{
-		entropyBit: false,
-		frames:     nil,
+		frames: nil,
 	}, nil
 }
 
@@ -499,7 +498,7 @@ var _ = Describe("Session", func() {
 	Context("sending packets", func() {
 		It("sends ack frames", func() {
 			packetNumber := protocol.PacketNumber(0x035E)
-			session.receivedPacketHandler.ReceivedPacket(packetNumber, true)
+			session.receivedPacketHandler.ReceivedPacket(packetNumber)
 			err := session.sendPacket()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(conn.written).To(HaveLen(1))
@@ -680,7 +679,7 @@ var _ = Describe("Session", func() {
 
 			It("sends a queued ACK frame only once", func() {
 				packetNumber := protocol.PacketNumber(0x1337)
-				session.receivedPacketHandler.ReceivedPacket(packetNumber, true)
+				session.receivedPacketHandler.ReceivedPacket(packetNumber)
 
 				s, err := session.GetOrOpenStream(5)
 				Expect(err).NotTo(HaveOccurred())