OK, let’s see if we can make out what you’re trying to do.
You want the child object to align itself with the ground. So its Y rotation is going to stay the same as the parent (more or less), but it’s going to tilt so that it stays parallel with the surface of the ground.
That’s… tricky. So first, you need to stop using phrases like “all I need to happen” regarding this problem. Those phrases imply that it’s simple, and it’s not. 
I happen to have some really cool code (if I do say so myself) that can do this. It casts four rays down (where the “wheels” are in my case, because it’s for a vehicle simulator), and adjusts the rotation of the object to conform to the terrain or other objects it’s driving over as well as possible.
Here’s that code, though it’s not going to work as-is for you unless your situation is very similar to mine (i.e. you have four cylinders that serve as wheels).
/*
This script "grounds" a truck by adjusting its vertical position
and angle so that all four wheels are on the ground, or as close
to it as possible.
*/
using UnityEngine;
using UnityEngine.Events;
using System.Collections.Generic;
public class Grounder : MonoBehaviour {
[Tooltip("Cylinders representing the wheels")]
public Transform[] wheels;
void Update() {
// We'll find where the center of each wheel "should" be in order for
// the bottom of the wheel to rest on the ground. Collect these up,
// and then find the proper position & orientation of the truck.
Vector3[] pts = new Vector3[4];
int qtyPts = 0;
foreach (Transform w in wheels) {
float wheelR = (w.localScale.x + w.localScale.z) * 0.25f;
// For direction, we'll go straight down for now, which really
// models the wheels as spheres... but that's a decent approximation
// for such wide truck tires.
Vector3 down = -Vector3.up;
//Debug.DrawLine(w.position, w.position + down * wheelR, Color.green, 0);
RaycastHit hit;
if (Physics.Raycast(w.position, down, out hit)) {
Vector3 p = hit.point - down * wheelR;
pts[qtyPts++] = p;
//Debug.DrawLine(p + Vector3.right, p - Vector3.right, Color.green, 0);
//Debug.DrawLine(p + Vector3.forward, p - Vector3.forward, Color.green, 0);
}
}
if (qtyPts >= 3) {
// Find the average normal of planes among all sets of 3 points.
Vector3 normal = NormalFromPoints(pts[0], pts[1], pts[2]);
if (qtyPts > 3) {
normal += NormalFromPoints(pts[1], pts[2], pts[3]);
normal += NormalFromPoints(pts[2], pts[3], pts[0]);
normal += NormalFromPoints(pts[3], pts[0], pts[1]);
normal *= 0.25f;
}
// Correct our "up" rotation.
Quaternion q = Quaternion.FromToRotation(transform.up, normal);
transform.rotation = q * transform.rotation;
// Also, correct our position by averaging errors from all points.
Vector3 dpos = Vector3.zero;
for (int i=0; i<qtyPts; i++) dpos += pts[i] - wheels[i].position;
dpos /= (float)qtyPts;
dpos.x = dpos.z = 0; // (only correct in Y)
transform.position += dpos;
//Debug.DrawLine(transform.position, transform.position + normal*5, Color.magenta, 0);
//Debug.DrawLine(transform.position, transform.position + transform.up*4, Color.gray, 0);
}
}
Vector3 NormalFromPoints(Vector3 ptA, Vector3 ptB, Vector3 ptC) {
// The normal of the plane is the cross-product of two vectors in it.
Vector3 result = Vector3.Cross(ptB - ptA, ptC - ptA);
result.Normalize();
return result;
}
}