diff --git a/felix/bpf/ut/bpf_prog_test.go b/felix/bpf/ut/bpf_prog_test.go
index 2f28f518642..a3a3c7c24c6 100644
--- a/felix/bpf/ut/bpf_prog_test.go
+++ b/felix/bpf/ut/bpf_prog_test.go
@@ -685,6 +685,21 @@ func initMapsOnce() {
 	})
 }
 
+// newTestRingBuf opens a reader on the shared cali_rb_evnt ring buffer used
+// by all BPF UT programs and drains any events left over from earlier tests,
+// so rb.Next() only observes events produced after this call. The caller is
+// responsible for closing the returned reader.
+//
+// Prefer this helper over calling ringbuf.New directly — the ring buffer map
+// is pinned and shared across tests, so a naked reader can pick up stray
+// records (TYPE_LOST_EVENTS markers, kprobe stats, etc.) and mis-parse them.
+func newTestRingBuf() *ringbuf.RingBuffer {
+	rb, err := ringbuf.New(ringBufMap, rbSize)
+	Expect(err).NotTo(HaveOccurred())
+	rb.Drain()
+	return rb
+}
+
 func cleanupMap(m maps.Map) {
 	log.WithField("map", m.GetName()).Info("Cleaning")
 	err := m.Iter(func(_, _ []byte) maps.IteratorAction {
diff --git a/felix/bpf/ut/flow_log_events_test.go b/felix/bpf/ut/flow_log_events_test.go
index 2198d34bf5d..872bb3653f2 100644
--- a/felix/bpf/ut/flow_log_events_test.go
+++ b/felix/bpf/ut/flow_log_events_test.go
@@ -21,7 +21,6 @@ import (
 	. "github.com/onsi/gomega"
 
 	"github.com/projectcalico/calico/felix/bpf/events"
-	"github.com/projectcalico/calico/felix/bpf/ringbuf"
 	"github.com/projectcalico/calico/felix/bpf/routes"
 )
 
@@ -34,8 +33,7 @@ func TestFlowLogV6Events(t *testing.T) {
 	ipv6 := ip6hdr.(*layers.IPv6)
 	udp := l4.(*layers.UDP)
 
-	rb, err := ringbuf.New(ringBufMap, rbSize)
-	Expect(err).NotTo(HaveOccurred())
+	rb := newTestRingBuf()
 	defer rb.Close()
 
 	rtKey := routes.NewKeyV6(srcV6CIDR).AsBytes()
@@ -54,6 +52,7 @@ func TestFlowLogV6Events(t *testing.T) {
 	Expect(err).NotTo(HaveOccurred())
 	e, err := events.ParseEvent(rawEvent)
 	Expect(err).NotTo(HaveOccurred())
+	Expect(e.Type()).To(Equal(events.TypePolicyVerdictV6))
 	evnt := events.ParsePolicyVerdict(e.Data(), true)
 	Expect(evnt.SrcAddr).To(Equal(ipv6.SrcIP))
 	Expect(evnt.DstAddr).To(Equal(ipv6.DstIP))
@@ -71,8 +70,7 @@ func TestFlowLogEvents(t *testing.T) {
 	ipv4 := iphdr.(*layers.IPv4)
 	udp := l4.(*layers.UDP)
 
-	rb, err := ringbuf.New(ringBufMap, rbSize)
-	Expect(err).NotTo(HaveOccurred())
+	rb := newTestRingBuf()
 	defer rb.Close()
 
 	rtKey := routes.NewKey(srcV4CIDR).AsBytes()
@@ -91,6 +89,7 @@ func TestFlowLogEvents(t *testing.T) {
 	Expect(err).NotTo(HaveOccurred())
 	e, err := events.ParseEvent(rawEvent)
 	Expect(err).NotTo(HaveOccurred())
+	Expect(e.Type()).To(Equal(events.TypePolicyVerdict))
 	evnt := events.ParsePolicyVerdict(e.Data(), false)
 	Expect(evnt.SrcAddr).To(Equal(ipv4.SrcIP))
 	Expect(evnt.DstAddr).To(Equal(ipv4.DstIP))
@@ -124,6 +123,7 @@ func TestFlowLogEvents(t *testing.T) {
 	Expect(err).NotTo(HaveOccurred())
 	e, err = events.ParseEvent(rawEvent)
 	Expect(err).NotTo(HaveOccurred())
+	Expect(e.Type()).To(Equal(events.TypePolicyVerdict))
 	evnt = events.ParsePolicyVerdict(e.Data(), false)
 	Expect(evnt.SrcAddr).To(Equal(ipv4.SrcIP))
 	Expect(evnt.DstAddr).To(Equal(ipv4.DstIP))
diff --git a/felix/bpf/ut/ringbuf_events_test.go b/felix/bpf/ut/ringbuf_events_test.go
index 8397b03a21c..c753541a862 100644
--- a/felix/bpf/ut/ringbuf_events_test.go
+++ b/felix/bpf/ut/ringbuf_events_test.go
@@ -22,8 +22,6 @@ import (
 	"github.com/gopacket/gopacket/layers"
 	. "github.com/onsi/gomega"
 	log "github.com/sirupsen/logrus"
-
-	"github.com/projectcalico/calico/felix/bpf/ringbuf"
 )
 
 const (
@@ -42,8 +40,7 @@ func TestRingBufBasic(t *testing.T) {
 	ipv4 := iphdr.(*layers.IPv4)
 	udp := l4.(*layers.UDP)
 
-	rb, err := ringbuf.New(ringBufMap, rbSize)
-	Expect(err).NotTo(HaveOccurred())
+	rb := newTestRingBuf()
 	defer rb.Close()
 
 	// Send a UDP packet and verify the event.
@@ -98,8 +95,7 @@ func TestRingBufReaderRecovery(t *testing.T) {
 	_, _, _, _, pktBytes, err := testPacketUDPDefault()
 	Expect(err).NotTo(HaveOccurred())
 
-	rb, err := ringbuf.New(ringBufMap, rbSize)
-	Expect(err).NotTo(HaveOccurred())
+	rb := newTestRingBuf()
 
 	runBpfUnitTest(t, "ringbuf_events.c", func(bpfrun bpfProgRunFn) {
 		res, err := bpfrun(pktBytes)
@@ -114,8 +110,7 @@ func TestRingBufReaderRecovery(t *testing.T) {
 	// Close the first reader and create a new one on the same map.
 	rb.Close()
 
-	rb2, err := ringbuf.New(ringBufMap, rbSize)
-	Expect(err).NotTo(HaveOccurred())
+	rb2 := newTestRingBuf()
 	defer rb2.Close()
 
 	// Send another event — the new reader should pick it up.
@@ -145,14 +140,11 @@ func TestRingBufFillup(t *testing.T) {
 	_, _, _, _, pktBytes, err := testPacketUDPDefault()
 	Expect(err).NotTo(HaveOccurred())
 
-	rb, err := ringbuf.New(ringBufMap, rbSize)
-	Expect(err).NotTo(HaveOccurred())
+	rb := newTestRingBuf()
 	defer rb.Close()
 
-	// Drain any leftover events from previous tests and reset the drops map
-	// so we start with a completely clean state.
-	rb.Drain()
-	// Reset the single-entry drops map (struct rb_drops_val = 16 bytes).
+	// Reset the single-entry drops map (struct rb_drops_val = 16 bytes) so
+	// this test's accounting isn't affected by earlier ring-buffer-full tests.
 	k := make([]byte, 4) // key = 0
 	zeroVal := make([]byte, 16)
 	err = ringBufDropsMap.Update(k, zeroVal)
@@ -232,8 +224,7 @@ func TestRingBufMultipleEvents(t *testing.T) {
 	RegisterTestingT(t)
 	hostIP = node1ip
 
-	rb, err := ringbuf.New(ringBufMap, rbSize)
-	Expect(err).NotTo(HaveOccurred())
+	rb := newTestRingBuf()
 	defer rb.Close()
 
 	numEvents := 10