diff --git a/src/knot/conf/base.c b/src/knot/conf/base.c
index c86288ae01def2a78b0ca0265b29639a302a1a30..ddbceff183152b6ce16c457185bbba4ee93bcf2c 100644
--- a/src/knot/conf/base.c
+++ b/src/knot/conf/base.c
@@ -122,12 +122,23 @@ static void init_cache(
 	}
 	conf->cache.srv_max_ipv6_udp_payload = conf_int(&val);
 
+	val = conf_get(conf, C_SRV, C_TCP_HSHAKE_TIMEOUT);
+	conf->cache.srv_tcp_hshake_timeout = conf_int(&val);
+
+	val = conf_get(conf, C_SRV, C_TCP_IDLE_TIMEOUT);
+	conf->cache.srv_tcp_idle_timeout = conf_int(&val);
+
+	val = conf_get(conf, C_SRV, C_TCP_REPLY_TIMEOUT);
+	conf->cache.srv_tcp_reply_timeout = conf_int(&val);
+
+	val = conf_get(conf, C_SRV, C_MAX_TCP_CLIENTS);
+	conf->cache.srv_max_tcp_clients = conf_int(&val);
+
+	val = conf_get(conf, C_SRV, C_RATE_LIMIT_SLIP);
+	conf->cache.srv_rate_limit_slip = conf_int(&val);
+
 	conf->cache.srv_nsid = conf_get(conf, C_SRV, C_NSID);
-	conf->cache.srv_max_tcp_clients = conf_get(conf, C_SRV, C_MAX_TCP_CLIENTS);
-	conf->cache.srv_tcp_hshake_timeout = conf_get(conf, C_SRV, C_TCP_HSHAKE_TIMEOUT);
-	conf->cache.srv_tcp_idle_timeout = conf_get(conf, C_SRV, C_TCP_IDLE_TIMEOUT);
-	conf->cache.srv_tcp_reply_timeout = conf_get(conf, C_SRV, C_TCP_REPLY_TIMEOUT);
-	conf->cache.srv_rate_limit_slip = conf_get(conf, C_SRV, C_RATE_LIMIT_SLIP);
+
 	conf->cache.srv_rate_limit_whitelist = conf_get(conf, C_SRV, C_RATE_LIMIT_WHITELIST);
 }
 
diff --git a/src/knot/conf/base.h b/src/knot/conf/base.h
index 5df6252adec8990d0d68cfa851c521a65a7be77d..fc346d00e38dd564a53ed79f10db8c002ee7a7d9 100644
--- a/src/knot/conf/base.h
+++ b/src/knot/conf/base.h
@@ -93,12 +93,12 @@ typedef struct {
 	struct {
 		int16_t srv_max_ipv4_udp_payload;
 		int16_t srv_max_ipv6_udp_payload;
+		int32_t srv_tcp_hshake_timeout;
+		int32_t srv_tcp_idle_timeout;
+		int32_t srv_tcp_reply_timeout;
+		int32_t srv_max_tcp_clients;
+		int32_t srv_rate_limit_slip;
 		conf_val_t srv_nsid;
-		conf_val_t srv_max_tcp_clients;
-		conf_val_t srv_tcp_hshake_timeout;
-		conf_val_t srv_tcp_idle_timeout;
-		conf_val_t srv_tcp_reply_timeout;
-		conf_val_t srv_rate_limit_slip;
 		conf_val_t srv_rate_limit_whitelist;
 	} cache;
 
diff --git a/src/knot/modules/dnsproxy.c b/src/knot/modules/dnsproxy.c
index 35f1e39c515cdf890b9aafad22f7305dfc849a3a..17c31753daa0f0699f1632e6c2a233d9dee490c6 100644
--- a/src/knot/modules/dnsproxy.c
+++ b/src/knot/modules/dnsproxy.c
@@ -88,8 +88,7 @@ static int dnsproxy_fwd(int state, knot_pkt_t *pkt, struct query_data *qdata, vo
 	}
 
 	/* Forward request. */
-	conf_val_t *val = &conf()->cache.srv_tcp_reply_timeout;
-	int timeout = conf_int(val) * 1000;
+	int timeout = 1000 * conf()->cache.srv_tcp_reply_timeout;
 	ret = knot_requestor_exec(&re, req, timeout);
 
 	knot_request_free(req, re.mm);
diff --git a/src/knot/nameserver/process_query.c b/src/knot/nameserver/process_query.c
index 68dc66ccaa1f82443f2f0bd6a241d92d20a2a06f..91d045d22db3bfe389aaf34a1fdd7d6669a45fe0 100644
--- a/src/knot/nameserver/process_query.c
+++ b/src/knot/nameserver/process_query.c
@@ -455,7 +455,7 @@ static int ratelimit_apply(int state, knot_pkt_t *pkt, knot_layer_t *ctx)
 	}
 
 	/* Now it is slip or drop. */
-	int slip = conf_int(&conf()->cache.srv_rate_limit_slip);
+	int slip = conf()->cache.srv_rate_limit_slip;
 	if (slip > 0 && rrl_slip_roll(slip)) {
 		/* Answer slips. */
 		if (process_query_err(ctx, pkt) != KNOT_STATE_DONE) {
diff --git a/src/knot/nameserver/update.c b/src/knot/nameserver/update.c
index aee4ca9115bde276ef03076ddfcaad7098de5123..96d8b22807c68d60065413e43df19a3fe3f83efa 100644
--- a/src/knot/nameserver/update.c
+++ b/src/knot/nameserver/update.c
@@ -242,8 +242,7 @@ static int remote_forward(conf_t *conf, struct knot_request *request, conf_remot
 	}
 
 	/* Execute the request. */
-	conf_val_t *val = &conf->cache.srv_tcp_reply_timeout;
-	int timeout = conf_int(val) * 1000;
+	int timeout = 1000 * conf->cache.srv_tcp_reply_timeout;
 	ret = knot_requestor_exec(&re, req, timeout);
 
 	knot_request_free(req, re.mm);
@@ -339,8 +338,7 @@ static void send_update_response(conf_t *conf, const zone_t *zone, struct knot_r
 		}
 
 		if (net_is_stream(req->fd)) {
-			conf_val_t *val = &conf->cache.srv_tcp_reply_timeout;
-			int timeout = conf_int(val) * 1000;
+			int timeout = 1000 * conf->cache.srv_tcp_reply_timeout;
 			net_dns_tcp_send(req->fd, req->resp->wire, req->resp->size,
 			                 timeout);
 		} else {
diff --git a/src/knot/query/query.c b/src/knot/query/query.c
index fa508ade71207e534c6260ce1b5aed30954a336f..ae078ee195e820dc1195ed890bc63f476fad777d 100644
--- a/src/knot/query/query.c
+++ b/src/knot/query/query.c
@@ -294,8 +294,7 @@ static int zone_query_request(knot_pkt_t *query, const conf_remote_t *remote,
 	}
 
 	/* Send the queries and process responses. */
-	conf_val_t *val = &param->conf->cache.srv_tcp_reply_timeout;
-	int timeout = conf_int(val) * 1000;
+	int timeout = 1000 * param->conf->cache.srv_tcp_reply_timeout;
 	ret = knot_requestor_exec(&re, req, timeout);
 
 	/* Cleanup. */
diff --git a/src/knot/server/tcp-handler.c b/src/knot/server/tcp-handler.c
index 1cc3a1cbecb839e78955cb32b2a7c92579de0e7a..29cf314e3d96bb0c274878fe57c3308af9403233 100644
--- a/src/knot/server/tcp-handler.c
+++ b/src/knot/server/tcp-handler.c
@@ -114,8 +114,7 @@ static int tcp_handle(tcp_context_t *tcp, int fd,
 
 	/* Timeout. */
 	rcu_read_lock();
-	conf_val_t *val = &conf()->cache.srv_tcp_reply_timeout;
-	int timeout = conf_int(val) * 1000;
+	int timeout = 1000 * conf()->cache.srv_tcp_reply_timeout;
 	rcu_read_unlock();
 
 	/* Receive data. */
@@ -178,8 +177,7 @@ int tcp_accept(int fd)
 #ifdef SO_RCVTIMEO
 		struct timeval tv;
 		rcu_read_lock();
-		conf_val_t *val = &conf()->cache.srv_tcp_idle_timeout;
-		tv.tv_sec = conf_int(val);
+		tv.tv_sec = conf()->cache.srv_tcp_idle_timeout;
 		rcu_read_unlock();
 		tv.tv_usec = 0;
 		if (setsockopt(incoming, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
@@ -207,8 +205,8 @@ static int tcp_event_accept(tcp_context_t *tcp, unsigned i)
 
 		/* Update watchdog timer. */
 		rcu_read_lock();
-		conf_val_t *val = &conf()->cache.srv_tcp_hshake_timeout;
-		fdset_set_watchdog(&tcp->set, next_id, conf_int(val));
+		int timeout = conf()->cache.srv_tcp_hshake_timeout;
+		fdset_set_watchdog(&tcp->set, next_id, timeout);
 		rcu_read_unlock();
 
 		return KNOT_EOK;
@@ -228,8 +226,8 @@ static int tcp_event_serve(tcp_context_t *tcp, unsigned i)
 	if (ret == KNOT_EOK) {
 		/* Update socket activity timer. */
 		rcu_read_lock();
-		conf_val_t *val = &conf()->cache.srv_tcp_idle_timeout;
-		fdset_set_watchdog(&tcp->set, i, conf_int(val));
+		int timeout = conf()->cache.srv_tcp_idle_timeout;
+		fdset_set_watchdog(&tcp->set, i, timeout);
 		rcu_read_unlock();
 	}
 
@@ -248,8 +246,8 @@ static int tcp_wait_for_events(tcp_context_t *tcp)
 	if (!is_throttled) {
 		/* Configuration limit, infer maximal pool size. */
 		rcu_read_lock();
-		conf_val_t *val = &conf()->cache.srv_max_tcp_clients;
-		unsigned max_per_set = MAX(conf_int(val) / conf_tcp_threads(conf()), 1);
+		int clients = conf()->cache.srv_max_tcp_clients;
+		unsigned max_per_set = MAX(clients / conf_tcp_threads(conf()), 1);
 		rcu_read_unlock();
 		/* Subtract master sockets check limits. */
 		is_throttled = (set->n - tcp->client_threshold) >= max_per_set;
diff --git a/tests/confio.c b/tests/confio.c
index 3e9aca2f10cccd763ed42f9184cae3f143ff7ae1..0da173f04e29e8dd19ee3ce26d6d1f3432da9b1a 100644
--- a/tests/confio.c
+++ b/tests/confio.c
@@ -894,9 +894,14 @@ static void test_conf_io_list()
 	ref = "server.version\n"
 	      "server.rate-limit\n"
 	      "server.listen\n"
+	      "server.tcp-handshake-timeout\n"
+	      "server.tcp-idle-timeout\n"
+	      "server.tcp-reply-timeout\n"
+	      "server.max-tcp-clients\n"
 	      "server.max-udp-payload\n"
 	      "server.max-ipv4-udp-payload\n"
-	      "server.max-ipv6-udp-payload";
+	      "server.max-ipv6-udp-payload\n"
+	      "server.rate-limit-slip";
 	ok(strcmp(ref, out) == 0, "compare result");
 }
 
@@ -905,9 +910,14 @@ static const yp_item_t desc_server[] = {
 	{ C_RATE_LIMIT,           YP_TINT,  YP_VNONE },
 	{ C_LISTEN,               YP_TADDR, YP_VNONE, YP_FMULTI },
 	// Required config cache items - assert fix.
+	{ C_TCP_HSHAKE_TIMEOUT,   YP_TINT,  YP_VNONE },
+	{ C_TCP_IDLE_TIMEOUT,	  YP_TINT,  YP_VNONE },
+	{ C_TCP_REPLY_TIMEOUT,	  YP_TINT,  YP_VNONE },
+	{ C_MAX_TCP_CLIENTS,	  YP_TINT,  YP_VNONE },
 	{ C_MAX_UDP_PAYLOAD,      YP_TINT,  YP_VNONE },
 	{ C_MAX_IPV4_UDP_PAYLOAD, YP_TINT,  YP_VNONE },
 	{ C_MAX_IPV6_UDP_PAYLOAD, YP_TINT,  YP_VNONE },
+	{ C_RATE_LIMIT_SLIP,	  YP_TINT,  YP_VNONE },
 	{ NULL }
 };