Can we see your BB testing function code? Also, when checking collisions with bounding volumes, I think it's very important to take model transformations into account (i.e. checking with transformed bounding boxes).

I don't know C#, so I'll suggest you something in C++. Hope you can understand and convert them for your needs.

First, a bounding box can be defined by minimum and maximum points. These points' components are retrieved from minimum and maximum values from all vertices' components, respectively. So, calculation is easy:
loop throug all vertices
{
min_x = the smallest x component of all vertices,
min_y = the smallest y component of all vertices,
min_z = the smallest z component of all vertices,

max_x = the biggest x component of all vertices,
max_y = the biggest y component of all vertices,
max_z = the biggest z component of all vertices,
}

Try this snippet to calculate your bounding box:
float _min = FLT_MIN; //in your code, this would be float.MinValue
float _max = FLT_MAX; //float.MaxValue

float min_x, min_y, min_z;
float max_x, max_y, max_z;
min_x = min_y = min_z = _max;
max_x = max_y = max_z = _min;
for (v = 0; v < numVertices; v++)
{
float x = vertices[v].x, y = vertices[v].y, z = vertices[v].z;
min_x = min (min_x, x);
min_y = min (min_y, y);
min_z = min (min_z, z);

max_x = max (max_x, x);
max_y = max (max_y, y);
max_z = max (max_z, z);
}

While checking for AABB collisions, I recommend you to check "transformed AABBs". Here a snippet from my engine to calculate "transformed AABB":

const AABB
AABB::Transform (const matrix4x4& objectWorldMatrix) const
{
AABB aabb;

vector3 c = this->CenterPt(), //CenterPt() returns (minPt + maxPt) / 2.0f;
e = .5f * this->Extents(); //Extents() returns (maxPt - minPt);

c = c.TransformCoord (objectWorldMatrix); //coord

matrix4x4 mat;
mat.Identity();

mat(0, 0) = objectWorldMatrix(0, 0);
mat(1, 0) = objectWorldMatrix(1, 0);
mat(2, 0) = objectWorldMatrix(2, 0);
mat(0, 1) = objectWorldMatrix(0, 1);
mat(1, 1) = objectWorldMatrix(1, 1);
mat(2, 1) = objectWorldMatrix(2, 1);
mat(0, 2) = objectWorldMatrix(0, 2);
mat(1, 2) = objectWorldMatrix(1, 2);
mat(2, 2) = objectWorldMatrix(2, 2);
e = e.TransformNormal (mat); //normal

aabb.MinPt = (m - e);
aabb.MaxPt = (m + e);

return aabb;
}

Note that the keypoint here is this: Don't even touch min and max points of an aabb, just build another one with transformed points and return it. So, before checking, don't touch your model mesh's original AABB (calculated once after loading/creating) and calculate a transformed one from this original "in every frame".

Now you got a transformed bounding box, and you can check collisions.

Try these. And tell us the results.

hth.
-R

AABB means "Axis Aligned Bounding Box" (i.e. transformed bounding box).

I didn't gave you any collision code. I gave bounding box calculation and transformation. So intersection/collision is up to you.

Transformation is the keypoint here because checking transformed bounding boxes (AABBs) is the only, the best and the most accurate way. Note that a bounding box must be calculated once after model creating/loading. And you must check the collisions/intersections between transformed bounding boxes.

So, in every frame:
1) Process Input: Get input from mouse, keyboard, joystick etc. and process them if you're using'em (e.g. to rotate and/or move a model or camera).
2) Update your models' transformations: Calculate world matrix for all your models. Calculate view and projection matrices if you need.
2-a) Update your models' bounding boxes: This is the keypoint. I talked about transforming bounding boxes in my previous post. Use world matrices to update bounding boxes. I say again: Don't even touch a model's original bounding box. Create a transformed one instead. And store it.
NOTE: I think you're something wrong in this step. For example, I think you're checking original (i.e. calculated after model creating) bounding boxes. They're always placed at world-space origin so they always instersects each other. Above code gives you how they are transformed.
3) Update physics: This means checking collisions/intersections for you. Don't forget: Don't update original bounding boxes. Create another ones over the originals but with transformed parameters. So, don't use original bounding boxes for checking collisions, use the transformed ones calculated in previous step instead.
4) Render: Whatever you like.

hth.
-R