diff --git a/include/proto/proxy.h b/include/proto/proxy.h
index e56de12..adb16ce 100644
--- a/include/proto/proxy.h
+++ b/include/proto/proxy.h
@@ -69,6 +69,8 @@
 {
 	fe->cum_feconn++;
 	update_freq_ctr(&fe->fe_sess_per_sec, 1);
+	if (fe->fe_sess_per_sec.curr_ctr > fe->fe_sps_max)
+		fe->fe_sps_max = fe->fe_sess_per_sec.curr_ctr;
 }
 
 /* increase the number of cumulated connections on the designated backend */
@@ -76,6 +78,8 @@
 {
 	be->cum_beconn++;
 	update_freq_ctr(&be->be_sess_per_sec, 1);
+	if (be->be_sess_per_sec.curr_ctr > be->be_sps_max)
+		be->be_sps_max = be->be_sess_per_sec.curr_ctr;
 }
 
 #endif /* _PROTO_PROXY_H */
diff --git a/include/proto/server.h b/include/proto/server.h
index e05a4ac..7479c2e 100644
--- a/include/proto/server.h
+++ b/include/proto/server.h
@@ -40,6 +40,8 @@
 {
 	s->cum_sess++;
 	update_freq_ctr(&s->sess_per_sec, 1);
+	if (s->sess_per_sec.curr_ctr > s->sps_max)
+		s->sps_max = s->sess_per_sec.curr_ctr;
 }
 
 #endif /* _PROTO_SERVER_H */
diff --git a/include/types/proxy.h b/include/types/proxy.h
index 7ef5fc8..9e49bd8 100644
--- a/include/types/proxy.h
+++ b/include/types/proxy.h
@@ -230,11 +230,13 @@
 	unsigned int feconn, feconn_max;	/* # of active frontend sessions */
 	unsigned int beconn, beconn_max;	/* # of active backend sessions */
 	struct freq_ctr fe_sess_per_sec;	/* sessions per second on the frontend */
+	unsigned int fe_sps_max;		/* maximum of new sessions per second seen on the frontend */
 	struct freq_ctr be_sess_per_sec;	/* sessions per second on the backend */
+	unsigned int be_sps_max;		/* maximum of new sessions per second seen on the backend */
 	long long cum_feconn, cum_beconn;	/* cumulated number of processed sessions */
 	long long cum_lbconn;			/* cumulated number of sessions processed by load balancing */
 	unsigned int maxconn;			/* max # of active sessions on the frontend */
-	unsigned int fe_maxsps;			/* max # of new sessions per second on the frontend */
+	unsigned int fe_sps_lim;		/* limit on new sessions per second on the frontend */
 	unsigned int fullconn;			/* #conns on backend above which servers are used at full load */
 	struct in_addr except_net, except_mask; /* don't x-forward-for for this address. FIXME: should support IPv6 */
 	struct in_addr except_to;		/* don't x-original-to for this address. */
diff --git a/include/types/server.h b/include/types/server.h
index a52a9d8..7c7a54e 100644
--- a/include/types/server.h
+++ b/include/types/server.h
@@ -124,6 +124,7 @@
 	long long retries, redispatches;		/* retried and redispatched connections */
 	long long failed_secu;			/* blocked responses because of security concerns */
 	struct freq_ctr sess_per_sec;		/* sessions per second on this server */
+	unsigned int sps_max;			/* maximum of new sessions per second seen on this server */
 	long long cum_sess;			/* cumulated number of sessions really sent to this server */
 	long long cum_lbconn;			/* cumulated number of sessions directed by load balancing */
 
