You can solve it this way - 
1. You need to notice that we need a data structure to answer queries of the form - How many prime numbers between L and R exist from node to some_ancestor(node). This value is equal to the number of prime nos. between L and R from root to node - number of prime nos. between L and R from root to some_ancestor(node). The obvious choice may be segment tree/fenwick tree. I will explain the soln. using segment tree.
2. For each query, compute LCA(A,B)=lca. This lca is the ancestor of both A and B, and we are interested in it. 
3. We will be processing the queries offline. To do this, for each query, find LCA(A,B)=lca and for each such lca, store in memory the answer - How many prime nos. between L and R exist from root to lca for only those L,R values in queries in which LCA(A,B) = lca. You can do this using a single DFS from root and upto each node in DFS, maintain a segment tree storing all the values from the root upto that point. 
Each node of this segment tree will represent the number of prime nos. which were seen on the path from the root to that node in range [left,right]. When you are on a particular node, you answer the queries for all L,R for which this node becomes the lca.
4. Do another DFS from root using the same method as in step - 3 (using another segment tree), but this time, you compute the answer described in step - 1.

We basically divide the query range from u to v as root to u, root to v and root to lca(u,v). Compute the answer for these paths, and you can restore the answer for the original query. To compute the answer for a particular node, we first store all the ranges (l,r) for that particular node. Notice that if all the values from the root to a node v are added to a bit, then we can find the answer using one range query. Now we can just perform dfs, add a node to the bit at the beginning of the DFS call and remove it from the BIT at the end of the DFS call. This will ensure that when we are a node, all its ancestors are in the bit.

Edit : same as above