SHA-3 maximal number of zeros (Padding) What is the maximum number of zeros, which are appended at the input- padding in messages? How large must the message be for this?
Let's start from the top and work down, using FIPS 202 as reference. Note that the KECCAK paper uses a somewhat different notation (!).
$$\operatorname{SHA3-224}(M) = \operatorname{KECCAK}[448] (M | 01, 224)$$
$$\operatorname{SHA3-256}(M) = \operatorname{KECCAK}[512] (M | 01, 256)$$
$$\operatorname{SHA3-384}(M) = \operatorname{KECCAK}[768] (M | 01, 384)$$
$$\operatorname{SHA3-512}(M) = \operatorname{KECCAK}[1024] (M | 01, 512)$$
this is explained as:

In each case, the capacity is double the digest length, i.e., $c = 2 \cdot d$, and the resulting input $N$ to $\operatorname{KECCAK}[c]$ is the message with the suffix appended, i.e, $N = M | 01$.

Now it is also given that

$\operatorname{KECCAK}[c] = \operatorname{SPONGE}[\operatorname{KECCAK-p}[1600, 24], \operatorname{pad10*1}, 1600 – c]$.

where $\operatorname{SPONGE}$ is defined as $\operatorname{SPONGE}[f, pad, r]$. This means that $r = 1600 - c$ which can be rewritten as $r = 1600 - 2d$.
This is the information that we need for chapter 4: SPONGE CONSTRUCTION

The padding rule, pad, is a function that produces padding, i.e., a string with an appropriate
length to append to another string. In general, given a positive integer $x$ and a non-negative
integer $m$, the output $\operatorname{pad}(x, m)$ is a string with the property that $m + \operatorname{len}(\operatorname{pad}(x, m))$ is a positive
multiple of $x$. Within the sponge construction, $x = r$ and $m = \operatorname{len}(N)$, so that the padded input
string can be partitioned into a sequence of $r$-bit strings. Algorithm 9 in Sec. 5.1 specifies the
padding rule for the KECCAK functions and, hence, the SHA-3 functions.

Here $N$ is the input string of Keccak / SHA3 and $m$ is therefore the length of the input string (in bits).
So great, we now can finally look at the definition of $\operatorname{pad10*1}$:

Within the sponge construction, $x = r$ and $m = \operatorname{len}(N)$

Let $j = (– m – 2) \bmod x$.
Return $P = 1 | 0^j | 1$.


Now negative modular calculations can be a bit confusing, but it is clear that no matter what, the maximum value of $j$ and thus the number of zero's is $x - 1$ or $r - 1$ as $x = r$. This is because $m$, the input length, can have any non-negative value. As this is for the sponge, this is also true for $\operatorname{KECCAK}[c]$ and therefore SHA3.
Now $m = \operatorname{len}(N)$ but $N = M|01$. In other words, the input $m$ is the message length - say $l$ - plus two bits. So that means that $j = (– m – 2) \bmod r = (– (l + 2) – 2) \bmod r = (–l - 2) – 2) \bmod r = -l - 4 \bmod r$. This maximum will be reached for $l = N \cdot r - 3$. This is kind of expected; if you have a minimal overhead of 4 bits for the padding then a message three bits shorter than the $r$ will require the maximum padding as the padding will overflow into the next block.

SHA3-224 means $r = 1600 - 448 = 1152$, so for $N \cdot 1152 - 3$ the maximum number of zero's is reached, which will be $r - 1 = 1151$ zero's.
Let's check this for $N = 1$: $\operatorname{len}(\{0,1\}^{1149}|01|1|0^{1151}|1) = 1149 + 1151 + 4 = 2304 = 2 \cdot 1152$. So that indeed leads to two times the rate $r$.

The usual input of hash algorithms isn't in bits, but in 8-bit bytes. In that case the input would simply be $N \cdot r$ for a maximum number of zero's that's of course $8 - 4 =4$ bits smaller. The number of zero bytes is of course $r / 8 - 2$ bytes.
Lets validate this again using SHA3-224. The first block of $r$ bytes would just be the message and the last block of $r$ bytes would consist of $06 | 00^{142} | 80$ in hexadecimals. This seems strange but that's because NIST uses little endian and flipped bit order (low order bits leftmost in the padding, but rightmost in the bytes, i.e. bit $b_7$ is on the right).