MYTH 1: If a horse has colic, keep him moving and don’t let him lie down or roll
{"content":"</p>
<p><strong>FACT:</strong> Horses, just like people, often prefer to lie down if they are suffering abdominal pain. Your horse will not “twist his gut” by lying down quietly.</p>
<p><div class="ad-container ad-container--mobile"><div id="post-inline-1" class="ipc-advert"></div></div></p>
<p>If symptoms are severe and rolling is violent, he may become cast or injure his head or other body parts against a fence or wall. If you are able to, move him to a large sand arena while you wait for the vet.</p>
<p>In some instances, short periods of intermittent walking exercise can increase intestinal motility and help resolve an impaction or colon displacement. Hours of endless walking, however, can leave a horse exhausted and a poor candidate for surgery.</p>
<p>Always take great care when handling a horse when he is pain, as his movements can become unpredictable and he will no longer pay attention to where you are standing. Do not put yourself in danger by approaching a violently colicking horse, even if you feel you can help. Wait for the arrival of your vet.</p>
<p><div class="ad-container ad-container--mobile"><div id="post-inline-2" class="ipc-advert"></div></div><section id="embed_code-31" class="hidden-md hidden-lg s-container sticky-anchor hide-widget-title widget_embed_code premium_inline_2"><section class="s-container listing--single listing--single-sharethrough image-aspect-landscape default sharethrough-ad sharethrough-ad-hidden">
  <div class="s-container__inner">
    <ul>
      <li id="native-content-mobile" class="listing-item">
      </li>
    </ul>
  </div>
</section></section></p>
<h3>MYTH 2: Paraffin oil will clear abdominal impaction</h3>
<p><strong>FACT:</strong> While paraffin oil can be used in certain cases as a marker for gastrointestinal motility, it is not beneficial in any other way.</p>
<p>It will not assist in dissolving impacted faecal material. Studies have shown that nasogastric intubation (inserting a tube through the nose and into the stomach) with an isotonic solution (water and salts) is the best method of softening impacted material to enable it to be passed. Try for yourself: place a pile of faecal material in a bucket of water overnight and another pile in a separate bucket with some paraffin/mineral oil. By the morning, the faeces will have dissolved in the water, but not in the oil.</p>
<p>Aspiration of paraffin oil into the lungs can result in pneumonia, which can be fatal. Nasogastric treatments should be administered only by a vet.</p>
<div class="ad-container ad-container--mobile"><div id="post-inline-3" class="ipc-advert"></div></div>
<h3>MYTH 3: If a colicky horse passes faeces, he will be OK</h3>
<p><strong>FACT:</strong> Feacal material can still be passed from the later portions of the intestinal tract, even if the horse has an obstruction further forward which has not resolved. Passing faeces is, in general, a good indication of gut motility, but your horse will still require a full examination regardless of whether he has or has not produced any droppings.</p>
<p><img class="lazyload blur-up aligncenter size-full wp-image-641239" src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2017/03/new-hh-placeholder-200x200.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/poo.jpg" alt="Pile fo horse poo in the field" width="630" height="400" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/poo.jpg 630w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/poo-135x86.jpg 135w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/poo-300x190.jpg 300w" sizes="(max-width: 630px) 100vw, 630px" /></p>
<div class="ad-container ad-container--mobile"><div id="post-inline-4" class="ipc-advert"></div></div>
<h3>MYTH 4: An injection usually puts things right</h3>
<p><strong>FACT:</strong> Abdominal colic can be defined anatomically to the stomach, small intestine, large intestine, caecum or small colon; into medical and surgical forms, and into strangulating and non- strangulating forms.</p>
<p>If your horse shows colicky signs, there are many potential causes. The most important thing that your vet will determine upon initial examination is whether or not he has a simple colic or a complicated colic, which may require further emergency management or surgery.</p>
<div class="ad-container ad-container--mobile"><div id="post-inline-5" class="ipc-advert"></div></div>
<p>For a simple spasmodic colic, your horse should respond well to antispasmodic and painkilling medication. If he has a strangulation of the small intestine or a large colon torsion (twisting), then injections will not fix the problem. Without an emergency exploratory laparotomy, he will die.</p>
<h3>MYTH 5: If a horse is referred to a specialist centre, they will always operate</h3>
<p><strong>FACT:</strong> The referral centre will reexamine the horse and can usually carry out more extensive examinations than in the field. Surgical intervention will only be proposed if it is necessary to save your horse’s life. Medical treatments are also available which may assist in certain cases. Importantly, your horse will be under constant observation.</p>
<p>Emergency surgery is a big deal and not every owner will be able to afford it. Other factors, such as the age of the horse or any other ongoing illnesses, may influence the decision to proceed with surgery or not. Delayed decisions can mean the difference between a successful outcome and an unsuccessful one, so plan ahead. Make sure you have an idea of what you would do if your horse needed surgery and find out where your nearest referral hospital is located. If you don’t have your own transport, keep an up-to-date list of people who could help you get your horse there — possibly in the middle of the night.</p>
<div id="attachment_641238" style="width: 640px" class="wp-caption aligncenter"><img aria-describedby="caption-attachment-641238" class="lazyload blur-up size-full wp-image-641238" src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2017/03/new-hh-placeholder-200x200.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-support-band_157193531_235512992.jpg" alt="colic support band post operation bandaging" width="630" height="400" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-support-band_157193531_235512992.jpg 630w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-support-band_157193531_235512992-135x86.jpg 135w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-support-band_157193531_235512992-300x190.jpg 300w" sizes="(max-width: 630px) 100vw, 630px" /><p id="caption-attachment-641238" class="wp-caption-text">Colic support band</p></div>
<h3>MYTH 6: Colic is always down to poor management</h3>
<p><strong>FACT:</strong> There are risk factors associated with certain types of colic. Crib-biters, for example, are more likely to develop epiploic foramen entrapment (where the small intestine becomes entrapped within an anatomical space within the abdomen), resulting in devitalisation of that segment of intestine. Recently-foaled mares are at increased risk of developing a colon torsion, while older horses are more susceptible to lipomas (benign fatty growths which form a stalk) that result in small intestinal strangulation.</p>
<p>Some colics just happen and it is difficult to prove a single episode could have been prevented. While good management will assist in preventing certain colics, including large colon impactions and some simple colonic obstruction (gas) cases, you can’t completely protect your horse.</p>
<p><strong>Reduce the risk by sticking to basic management guidelines:</strong></p>
<ul>
<li>Maintain good pasture management and carry out regular faecal egg counts, with targeted deworming as necessary.</li>
<li>Arrange six-to-12-monthly dental check-ups by your vet or a qualified equine dental technician registered with the British Association of Equine Dental Technicians (BAEDT) or WorldWide Association of Equine Dentistry (WWAED).</li>
<li>Provide adequate good-quality roughage in the form of hay or haylage, with daily access to pasture where possible.</li>
<li>Feed concentrates little and often — do not overload the stomach with large feeds.</li>
<li>Avoid abrupt changes in feeding and exercise programmes.</li>
<li>Allow constant access to a supply of clean drinking water. Some horses drink less if it is cold, so take extra care to monitor water intake in winter.</li>
<li>Do not allow your horse to become overweight.</li>
</ul>
<p><img class="lazyload blur-up aligncenter size-full wp-image-641237" src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2017/03/new-hh-placeholder-200x200.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-operation-5171950.jpg" alt="Colic surgery" width="630" height="400" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-operation-5171950.jpg 630w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-operation-5171950-135x86.jpg 135w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/14/2018/01/colic-operation-5171950-300x190.jpg 300w" sizes="(max-width: 630px) 100vw, 630px" /></p>
<h3>MYTH 7: For an older horse, colic is a death sentence</h3>
<p><strong>FACT:</strong> An older horse may be less well-equipped physically than a young horse to deal with general anaesthesia and a long recovery. The major factor, however, which appears to affect survival in geriatric (20 years plus) patients is owner decision-making.</p>
<p>An owner may be less willing to put an older horse through surgery because they feel it’s not fair to do so, or for purely economic reasons. In addition, older horses may no longer be insured, so the finances for surgery may not be available.</p>
<p>Studies have shown that geriatric horses with colic have a lower survival-to-discharge rate. Yet for those who recover from anaesthesia, the survival rate for most types of colic is not significantly different, meaning that a greater proportion of older horses are euthanased during surgery for reasons such as those already mentioned. Geriatric horses are also more likely to be euthanased without surgical intervention.</p>
<p>Try to base your decisions on facts and let your vet guide you through the process. The hardest call may be the best for your horse, even if it is heartbreaking for you.</p>
<h3>MYTH 8: Horses rarely resume an athletic career after surgery</h3>
<p><strong>FACT:</strong> Studies have shown that a large percentage of horses undergoing surgery will return to previous levels of work.</p>
<div class="injection"></div>
<p>In a recent study, 76% of horses who had raced prior to surgery resumed racing, with no difference in performance variables when compared to horses of a similar age who did not have colic surgery. Similarly, 76% of performance horses returned to intended use after 12 months, with 66% performing at higher levels in a second study.</p>
<p>A third study on performance horses reported that 83.5% returned to previous or higher levels of competition following surgery. Many top horses have resumed an international competition career following life-saving surgery.</p>
<p><em>Ref: Horse &amp; Hound; 4 January 2018</em></p>
<p>
"}