When Karen Shepherd’s home-bred dressage gelding Pepperwood Mister Mole developed sudden and severe lameness, the very last thing she suspected was laminitis.
{“content”:”
<p>Yet the<strong> shock diagnosis</strong> for the 17.2hh Hanoverian was the start of a <strong>year-long battle to save Mole’s life</strong> and return him to soundness. It’s a reminder that this crippling disease can affect all shapes and sizes.</p>
<p>Mole’s story began in December 2010, when he was given antibiotics for the first time following an infection. In a lean and fit condition, having recently competed at medium level, Mole was stabled because there was snow on the ground. His groom had just lunged him gently when she noticed that he then <strong>wouldn’t walk.</strong></p>
<p>“The vet knew it was laminitis after feeling his digital pulse and seeing his stance,” says Karen, who was abroad at the time and returned home immediately. “My farrier, Steve Fisher, was amazing, and to this day I think it’s <strong>thanks to him that Mole is still alive.</strong></p>
<p>“Steve came out over Christmas to fit and refit <strong>Styrofoam pads</strong> under his hooves. I remember us sitting with our backs to the stable wall, on Boxing Day, just looking at Mole. <strong>We were desperate.”</strong></p>
<h3>Hitting a low</h3>
<p>Mole was given a sedative and painkillers and confined to a stable with a padded floor, where he was <strong>trickle-fed well-soaked hay.</strong></p>
<p>“The first X-rays showed no rotation of the pedal bones,” recalls Karen. “But we hit the lowest point when further X-rays four weeks later showed that the <strong>bone in one foot had rotated to within 2mm of the sole (pictured top).</strong> The vet went very quiet. I don’t think anyone believed that a 17.2hh horse could survive that.”</p>
<p>Karen called in remedial farrier Richard Lovejoy, of Liphook Equine Hospital, Hants.</p>
<p>“Mole was a true sinker,” says Richard, referring to the severity of rotation. “He had a great regular farrier in Steve, who had done some really good first aid to give the hooves essential padding and support, but the <strong>pedal bone was threatening to come through the sole.</strong> We decided to fit<strong> eurothane supports known as Steward Clogs.</strong></p>
<p>[caption id="attachment_529185" align="aligncenter" width="630"]<img class="size-full wp-image-529185" src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2016/03/Clog-ground-view-horse.jpg" alt="Steward clog" width="630" height="400" /> Steward clog[/caption]</p>
<p>“These create the same effect as the heart bar shoe but with additional benefits. You can nail, screw, glue or cast them to the foot, sculpting them to fit. They create a <strong>multi-directional ‘breakover’</strong>, reducing shear forces and leverage and aiding movement.</p>
<p>“You can’t push the pedal bone back into position, but <strong>clogs allow the foot to remodel and the sole to thicken,”</strong> adds Richard. “Different options exist to help laminitis cases, but Mole did well with clogs packed with impression material.”</p>
<p>Richard refitted the clogs three times at five-week intervals, before beginning the long, slow process of trimming the foot gradually to counteract the effect of bone rotation and sinking.</p>
<p>Things were finally looking up for the stoic Hanoverian.</p>
<p>“The bone didn’t penetrate and the hoof capsule remained attached at the coronary band, but both were knocking on the door,” says Richard.</p>
<h3>Management methods</h3>
<p>After lengthy rehab, including<strong> six months of walking in-hand</strong>, Mole was able to be ridden again. He returned to competition a year after initial diagnosis, later winning the advanced medium freestyle at the southern regional championships, and last month becoming a regional prix st georges runner-up.</p>
<p>Now 15, he is training at grand prix. <strong>Karen opened a bottle of champagne when he did 15 one-time changes.</strong></p>
<p>“I’ve researched the subject to find the best possible ways to manage a post-laminitic,” she says. “Mole leads a fairly normal life now, but is only grazed in-hand or put in a round pen to roll and graze.</p>
<p>“He was on top-quality haylage but I never feed this now, sticking instead to good-quality meadow hay and soaking it if necessary,” she adds. “We’re careful not to turn the horses out with frost on the ground, or even later in the day when the weather is warmer but the sugar is still in the grass. And I’m particularly wary of steroids or antibiotics, or anything that can destabilise the natural balance of the gut flora.”</p>
<p>Karen believes that some warmbloods are genetically susceptible to laminitis and should be treated more like a Welsh cob than a thoroughbred in their diet.</p>
<p>“We’re more aware that many warmbloods slot into the ‘easy keeper’ category,” agrees Richard. “They <strong>often test positive for equine metabolic syndrome (EMS)</strong>. Mole wasn’t a fat horse, but he obviously wasn’t dealing with the sugars well.”</p>
<p>Vets report that horses can get laminitis the way people have headaches; as in Mole’s case, the cause is often unclear. Whatever the reasons behind his laminitic episode, Mole’s recovery has been remarkable.</p>
<p>“You don’t think that laminitis will happen, but, if it does, don’t give up,” says Karen, who has the <strong>framed X-rays hanging on her tack room wall</strong> as a reminder of how close Mole was to losing the fight. “Every day I ride that horse, I feel blessed.”</p>
<p>[caption id="attachment_529186" align="aligncenter" width="630"]<img class="size-full wp-image-529186" src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2016/03/3-Mole-Wellington-PL-PSG.jpg" alt="Karen Shepherd &amp; Pepperwood Mister Mole" width="630" height="400" /> Karen Shepherd &amp; Pepperwood Mister Mole[/caption]</p>
<h3>Who is at risk?</h3>
<p>Competition horses may have a <strong>higher risk</strong> of laminitis than we think, explains Victoria South MRCVS.</p>
<p>The majority of laminitis cases seen in the UK are due to<strong> hormone disorders</strong> — either equine metabolic syndrome (EMS) or <strong>equine Cushing’s disease (also known as PPID).</strong></p>
<p>EMS is caused by genetics, obesity, and lack of fitness, which lead to problems with insulin regulation. Horses with EMS have inappropriately high insulin levels in response to sugars and starches in their diet.</p>
<p>We can all imagine an overweight, cresty pony grazing on plentiful grass in the spring and predict that he has a high risk of developing laminitis. He has the genes, obesity and management (diet/fitness), so he ticks all the boxes for EMS.</p>
<p>Owners often assume that competition horses cannot have EMS and are not at risk from laminitis because they are “sporty types”, not good-doers. But in reality, <strong>many will have good-doer genes that promote EMS and an exaggerated insulin response to dietary sugars and starches.</strong></p>
<p>We are not as good as we think we are at assessing body condition — and therefore obesity — in horses. Studies show that <strong>owners tend to underestimate their horse’s bodyweight and condition.</strong></p>
<p>As Richard Lovejoy says, this is especially hard to assess in warmblood breeds. These horses may have minor external fat deposits over the crest, shoulder and rump, but <strong>can carry substantial intra-abdominal fat deposits</strong> that are just as important in causing EMS as more obvious obesity in a native pony.</p>
<p>The final EMS risk factor is <strong>fitness</strong>. Studies have demonstrated that dressage horses do not work at the same cardiovascular intensity as racehorses and event horses. This becomes increasingly important if they are suddenly out of work for any reason.</p>
<p>If there are rapid changes to a competition horse’s management, then it is sensible to reduce his dietary intake to reduce the risk of developing EMS and laminitis.</p>
<p>Since we cannot rely on body condition scoring to estimate laminitis risk, and fitness varies, it’s great that there are reliable, objective<strong> blood tests</strong> to diagnose EMS.</p>
<p>If you are concerned about your horse’s laminitis risk, ask your vet to test for EMS and equine Cushing’s disease. A blood sample to measure insulin levels is taken after an overnight fast, or as a dynamic test (blood testing after feeding glucose). Equine Cushing’s disease is diagnosed by checking adrenocorticotropic hormone (ACTH) levels on a blood sample.</p>
<p>These tests are safe and are performed by equine vets every day.</p>
<p><em>Ref: Horse &amp; Hound; 10 March 2016</em></p>
”}
