Compute several histograms with multiple filter conditions
I'm going to assume that each filter is a predicate on rows that identifies whether that row should be kept or discarded.  If so, then yes, this can be solved with many fewer than $O(Z^2)$ applications of the filters.  I'll describe two algorithms with different tradeoffs between time vs space: the first applies $O(Z)$ filters but uses $O(ZK)$ memory; the second applies $O(Z \lg Z)$ filters and uses just $O(K \lg Z)$ memory.  In both, let $F_1,\dots,F_Z$ denote the filters.
Algorithm 1: minimizing computation time
Here is an algorithm that applies $O(Z)$ applications filters and uses $O(ZK)$ memory.  (This corresponds to something like $O(ZK)$ time and $O(ZK)$ memory.)  Roughly speaking the algorithm computes a &quot;prefix sum&quot; and a &quot;suffix sum&quot;, using two linear scans.  In more detail:

For each $i$, compute the subset $S_i$ of rows that are retained if you apply filters $F_1,\dots,F_i$.

For each $j$, compute the subset $S'_j$ of rows that are retained if you apply filters $F_j,\dots,F_Z$.

For each $i$, compute the intersection $S_{i-1} \cap S'_{i+1}$; this is the set of rows that are retained if you apply all the filters except for $F_i$.


Note that step 1 can be done in a linear scan using a total of $Z$ applications of filters, as you can obtain $S_{i+1}$ from $S_i$ using a single application of $F_{i+1}$.  Similarly step 2 can be done using $Z$ applications of filters, for a total of $2Z=O(Z)$ applications of filters.  Unfortunately you have to store all of $S_1,\dots,S_Z,S'_1,\dots,S'_Z$, which takes $O(ZK)$ memory.
Algorithm 2: minimizing memory usage
A divide-and-conquer algorithm can solve the problem with $O(Z \lg Z)$ applications of filters and $O(K \lg Z)$ memory.  (This corresponds to approximately $O(ZK \lg Z)$ time and $O(K \lg Z)$ memory.)  The algorithm works like this:

If $Z=1$ or $Z=2$, the problem is trivial; this is the base case.  Otherwise:

Compute the subset of rows that are retained if you apply filters $F_1,\dots,F_{Z/2}$.  Then, recursively apply the algorithm to this reduced set of rows and to the filters $F_{Z/2+1},\dots,F_Z$.

Compute the subset of rows that are retained if you apply filters $F_{Z/2+1},\dots,F_Z$.  Then, recursively apply the algorithm to this reduced set of rows and to the filters $F_1,\dots,F_{Z/2}$.


Notice that you can compute the subsets of rows in steps 2,3 with $O(Z)$ applications of filters.  So, if we let $T(Z)$ denote the number of filter applications used by this algorithm when running on $Z$ filters, we have the recurrence relation
$$T(Z) = 2 T(Z/2) + O(Z),$$
which has the solution $T(Z) = O(Z \lg Z)$.  The claimed running time follows; and it's not too hard to see that the amount of memory used is as claimed, too (as there are $O(\lg Z)$ levels to the recursion tree, and you store $O(K)$ records per level of the recursion tree at a time).
Can we do better?
A natural question is to ask whether it is possible to find an algorithm that is optimal in both time and memory usage: e.g., $O(Z)$ applications of filters and $O(ZK)$ memory.  I don't know whether that is possible or not.