Suppose I have a single block $n$-qubit stabilizer code that can correct a weight 1 error (so the distance is $d=3$). If I apply a $1$-transversal gate of the form $U = U_1 \otimes U_2 \otimes \cdots \otimes U_n$, then if there was 1 error before I applied the gate, there will still only be 1 error after I apply the gate. So $U$ is called fault tolerant because error correction works before and after applying $U$.
On the other hand, consider a $2$-transversal gate of the form $V = V_1 \otimes V_2 \otimes \cdots \otimes V_N$ where each $V_i$ acts on either 1 or 2 qubits, for example $\mathrm{CNOT} \otimes X \otimes Y$. Then if there is 1 error before we apply $V$, there could be 2 errors on the output. This means $V$ is not fault-tolerant (as usually defined) because we could correct the error before we applied $V$ but we could not after we applied $V$.
However, if I simply choose a code with a larger distance, say $d=5$ (which can correct 2 errors or less) then it seems like $V$ should be considered "fault-tolerant". Because if a weight 1 error happens and we apply $V$ then the output will have a maximum of 2 errors. And because the code can correct 2 errors we can still undo this correctly. However, the "fault-tolerant distance" of the code has changed - we can only tolerate a single error (if 2 errors happen then after we apply $V$ there could be 4 errors). So even though the code has $d=5$, the "fault-tolerant distance" is $d_{FT}=3$.
Is my understanding correct? I really have never seen this mentioned anywhere but it seems fairly obvious (unless I am missing something)? Reference?