diff --git a/src/pdch.cpp b/src/pdch.cpp
index 17a2d50..618dbf4 100644
--- a/src/pdch.cpp
+++ b/src/pdch.cpp
@@ -371,8 +371,6 @@
 		osmo_fsm_inst_dispatch(new_tbf->state_fsm.fi, TBF_EV_ASSIGN_ACK_PACCH, NULL);
 		/* stop pending assignment timer */
 		new_tbf->t_stop(T0, "control acked (DL-TBF)");
-		if (new_tbf->check_n_clear(GPRS_RLCMAC_FLAG_TO_DL_ASS))
-			LOGPTBF(new_tbf, LOGL_NOTICE, "Recovered downlink assignment\n");
 
 		tbf_assign_control_ts(new_tbf);
 		return;
diff --git a/src/tbf.cpp b/src/tbf.cpp
index 3c0c530..0154bab 100644
--- a/src/tbf.cpp
+++ b/src/tbf.cpp
@@ -630,12 +630,6 @@
 		/* Signal timeout to FSM to reschedule UL assignment */
 		osmo_fsm_inst_dispatch(this->ul_ass_fsm.fi, TBF_UL_ASS_EV_ASS_POLL_TIMEOUT, NULL);
 	} else if (dl_ass_state_is(TBF_DL_ASS_WAIT_ACK)) {
-		if (!(state_fsm.state_flags & (1 << GPRS_RLCMAC_FLAG_TO_DL_ASS))) {
-			LOGPTBF(this, LOGL_NOTICE,
-				"Timeout for polling PACKET CONTROL ACK for PACKET DOWNLINK ASSIGNMENT: %s\n",
-				tbf_rlcmac_diag(this));
-			state_fsm.state_flags |= (1 << GPRS_RLCMAC_FLAG_TO_DL_ASS);
-		}
 		bts_do_rate_ctr_inc(bts, CTR_RLC_ASS_TIMEDOUT);
 		bts_do_rate_ctr_inc(bts, CTR_PDA_POLL_TIMEDOUT);
 		if (n_inc(N3105)) {
diff --git a/src/tbf.h b/src/tbf.h
index 15b7de3..b8f1e18 100644
--- a/src/tbf.h
+++ b/src/tbf.h
@@ -131,7 +131,6 @@
 #define GPRS_RLCMAC_FLAG_DL_ACK		3 /* downlink acknowledge received  */
 #define GPRS_RLCMAC_FLAG_TO_UL_ACK	4
 #define GPRS_RLCMAC_FLAG_TO_DL_ACK	5
-#define GPRS_RLCMAC_FLAG_TO_DL_ASS	6
 #define GPRS_RLCMAC_FLAG_TO_MASK	0xf0 /* timeout bits */
 
 #define T_START(tbf, t, T, r, f) tbf->t_start(t, T, r, f, __FILE__, __LINE__)
diff --git a/src/tbf_dl_ass_fsm.c b/src/tbf_dl_ass_fsm.c
index 8085fbd..cf09588 100644
--- a/src/tbf_dl_ass_fsm.c
+++ b/src/tbf_dl_ass_fsm.c
@@ -182,11 +182,16 @@
 
 static void st_wait_ack(struct osmo_fsm_inst *fi, uint32_t event, void *data)
 {
+	struct tbf_dl_ass_fsm_ctx *ctx = (struct tbf_dl_ass_fsm_ctx *)fi->priv;
+
 	switch (event) {
 	case TBF_DL_ASS_EV_RX_ASS_CTRL_ACK:
 		tbf_dl_ass_fsm_state_chg(fi, TBF_DL_ASS_NONE);
 		break;
 	case TBF_DL_ASS_EV_ASS_POLL_TIMEOUT:
+		LOGPTBF(ctx->tbf, LOGL_NOTICE,
+			"Timeout for polling PACKET CONTROL ACK for PACKET DOWNLINK ASSIGNMENT: %s\n",
+			tbf_rlcmac_diag(ctx->tbf));
 		/* Reschedule Pkt Dl Ass */
 		tbf_dl_ass_fsm_state_chg(fi, TBF_DL_ASS_SEND_ASS);
 		break;
