
<p><strong>Halina S.H.</strong> (e. Maharajah), ägd av K M Hästfarm i Holm AB och uppfödd av Eril Bendz, skickades till ledningen av Gustav Johansson, men det var en konkurrents felsteg som tog henne till den positionen. Eller egentligen inte. Halina S.H. kom först till plankan, men från springspår öppnade favoriten Sainz Zon snabbare och var på väg till ledningen när hon plötsligt tappade stilen och Carl Johan Jepson var tvungen att rädda henne från galopp.</p>



<p>Det lämnade då Halina S.H. i tät och Gustav Johansson fick styra loppet som han ville. Ledarryggens Evangelista Face fick chansen på upploppet och de två täthästarna stred sida vid sida ända in till mållinjen, där Halina S.H. hade ett knappt men säkert grepp. Maharajah-dottern vann på 1.15,1/2.140 meter.</p>



<p class="has-text-align-center">***</p>



<p>V85-2, ett försök i Diamantstoet utmynnade i en tät slutstrid där flera hästar såg ut att ha god chans till segern med 100 meter kvar. Favoriten Nephtys Boko styrde i ledningen och i rygg satt Victor Rosleff med Ola Karlssons <strong>Victoria L.L.</strong> (e. From Above).</p>



<p>Den sistnämnda sändes ner på open stretch och tog upp jakten på ledaren, samtidigt som det kom anfall från flera andra hästar på målrakan. Snabbast gick Annabelle, som hade fått fritt från tredje inner, men hon var aningen för sent ute, för längst in sluggade sig Victoria L.L. till segern på 1.13,2a/2.140 meter. </p>



<p>C Petersson äger och Lena Hedendahl har fött upp vinnaren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.16.37.34-617x338.jpg" alt="" class="wp-image-819567"/><figcaption class="wp-element-caption">Victoria L.L. kniper segern på open stretch.</figcaption></figure>



<p class="has-text-align-center">***</p>



<p>Gulddivisionen, V85-3, blev en ganska händelsefattig historia där favoriten <strong>High On Pepper</strong> (e. Ready Cash) kom till ledningen i tidigt skede av loppet. Spänningen kom sista 100 meterna när Karat River närmade sig på open stretch och för ett ögonblick kändes det som att Johan Untersteiners häst skulle ta sig förbi den store favoriten.</p>



<p>Men High On Pepper sträckte snyggt på sig via 1.09,0 sista halvvarvet och insatsen var på det stora hela stark. Katja Melkkos åttaåring vann på 1.13,1a/2.640 meter.</p>



<p>Pepper AB &#038; Silkstone HB äger High On Pepper som är uppfödd av Tina Dale Brauti.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.16.58.57-617x302.jpg" alt="" class="wp-image-819575"/><figcaption class="wp-element-caption">High On Pepper och Jorma Kontio vann gulddivisionen.</figcaption></figure>



<p class="has-text-align-center">***</p>



<p>Martine O Sövik lär inte glömma lördagen den 14 februari 2026. Först vann hon montéloppet innan V85-omgången med<strong> G.G. d&#8217;Asti</strong> (e. Coktail Jet) och när klass III mötte klass II över 2.640 meter slog hon till igen. </p>



<p>Den här gången satt hon bakom egentränade <strong>Bellton Memphis</strong> (e. Cash Gamble), som hon serverade en resa i tredje inner. Det såg inte särskilt ljust ut för henne på upploppet dock, men mellan hästar, på ett spår mellan open stretch och innerspåret lyckades hon hitta fritt med Bellton Memphis och det fanns rejält krut i den femårige valacken sista 75 meterna. Med lätthet tog sig ekipaget förbi samtliga konkurrenter och Bellton Memphis vann på 1.16,0/2.640 meter.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.17.24.18-617x271.jpg" alt="" class="wp-image-819583" style="width:677px;height:auto"/><figcaption class="wp-element-caption">175 meter från mål såg det inte så lovande ut för Bellton Memphis, som här sitter som trea på innerspår.</figcaption></figure>



<p>Jan Simenstad äger och Thomas &#038; Nina Backan har fött upp Bellton Memphis.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.17.24.28-1-617x333.jpg" alt="" class="wp-image-819584"/><figcaption class="wp-element-caption">Kort före mål var Bellton Memphis först.</figcaption></figure>



<p class="has-text-align-center">***</p>



<p>Spår 11 över kort distans är inte en lätt nöt att knäcka, men Mattias Djuses <strong>Rya Håleryd </strong>(e. Maharajah) löste uppgiften i stodivisionen på imponerande vis. </p>



<p>En rejäl svepning från fjärde ytter på sista bortre långsidan, dödens sista 500 meterna och grepp, med sträckta linor hos kusken Magnus Djuse, 200 från mål. Rya Håleryd försvann, okörd till vinst på 1.13,3a/1.640 meter.</p>



<p>Håleryd AB har fött upp det femåriga stoet som ägs av Stall Hoven Droven &#8211; Easy.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.17.45.05-617x296.jpg" alt="" class="wp-image-819587"/><figcaption class="wp-element-caption">Totalt överlägsen var hon, Rya Håleryd för Magnus A Djuse.</figcaption></figure>



<p class="has-text-align-center">***</p>



<p>Dagens mest känslosamma stund inträffade i samband med silverdivisionens försök. Ulf Ohlsson satt bakom Heikki Matias Koskelas <strong>Makalu Doc</strong> (e. S.J.&#8217;s Caviar), som var överlägsen i ett lopp där det kördes för fulla muggar i täten samtidigt som Makalu Doc inte behövde göra något alls egentligen, i den köposition han satt i.</p>



<p>Ledande Vinci Nice och dödenstravande Xanthis Hilton höll tempot uppe och efter 1.11 första kilometern blev det stumma ben sista biten. Makalu Doc hade i slutsvängen redan kopplat grepp om loppet och segern blev mycket lätt på fina 1.12,2a/2.140 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.18.10.18-617x624.jpg" alt="" class="wp-image-819592"/><figcaption class="wp-element-caption">Makalu Doc efter segern i silverdivisionen.</figcaption></figure>



<p>Heikki Koskelas son Jarno gick tragiskt bort nyligen efter en tids sjukdom i cancer och det var en mycket samlad pappa och tränare som hedrade Jarno Koskela i och med segern. Det kan ha varit minst lika känslosamt för uppfödaren Dan Hultberg. Dan, som hade Immortal Doc till start i Prix d&#8217;Amérique i Paris för tre veckor sedan, reste till Frankrike med den mycket gode vännen Tomas Thell den veckan och tragiskt nog gick även Tomas bort under söndagen på Vincennes.</p>



<p>Firma Koskela Stable &#038; Josefsson H M äger sexårige Makalu Doc.</p>



<p class="has-text-align-center">***</p>



<p>Vad vore en V85-omgång på sydliga breddgrader utan en vinst för Johan Untersteiner? Stefan Persson satt upp bakom <strong>Global Futurity</strong> (e. Greenshoe) som från ledningen inte hade några bekymmer alls med att hålla motståndarna ifrån sig i klass I-försöket över kort distans.</p>



<p>Global Futurity höll spänsten hela vägen och segern får beskrivas som vattentät på 1.11,6a/1.640 meter. Global Farm AB har fött upp och Stall Silvio AB äger. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.18.28.07-617x317.jpg" alt="" class="wp-image-819597"/><figcaption class="wp-element-caption">Global Futurity och Stefan Persson vinner klass I.</figcaption></figure>



<p class="has-text-align-center">***</p>



<p>Vad vore en V85-omgång utan att Johan Untersteiner vinner fler än ett lopp? Bronsdivisionen avslutade omgången och från innerspår höll<strong> Ideal Stone </strong>(e. Wishing Stone) ledningen för Stefan Persson. Persson, som inte är sen att ta tillvara på de chanser han får som kusk, fick favoriten Follow Him på utsidan under loppets gång och de två täthästarna kämpade sida vid sida på upploppet, samtidigt som Mister Kabuki fick upp bra fart på open stretch.</p>



<p>Det blev hårt i mål, men Ideal Stone höll undan till seger på 1.12,7a/2.140 meter. Merwestaal Racing Stables B.V. äger Ideal Stone som är uppfödd av Cowboyland Aalborg A/S &#038; Rivers ApS i Danmark.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260214kl.18.48.12-617x282.jpg" alt="" class="wp-image-819603" style="width:617px;height:auto"/><figcaption class="wp-element-caption">Hårt i mål mellan tre hästar i avslutningen. Ideal Stone, i mitten, höll undan till segern.</figcaption></figure>


<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Rätt V85 Åby 14/2 2026								</h3>
<div class="content">
<p><strong>V85-1:</strong> 3 Halina S.H.<br /><strong>V85-2:</strong> 2 Victoria L.L. (värde 142 kr)<br /><strong>V85-3</strong>: 3 High On Pepper (värde 158 kr)<br /><strong>V85-4:</strong> 1 Bellton Memphis (värde 372 kr)<br /><strong>V85-5: </strong>11 Rya Håleryd (värde 944 kr)<br /><strong>V85-6: </strong>9 Makalu Doc (värde 1.633 kr)<br /><strong>V85-7:</strong> 3 Global Futurity (värde 2.507 kr)<br /><strong>V85-8:</strong> 1 Ideal Stone</p>
<p><strong>Utdelning åtta rätt:</strong> 15.746 kr<br /><strong>Utdelning sju rätt:</strong> 215 kr<br /><strong>Utdelning sex rätt: </strong>16 kr<br /><strong>Utdelning fem rätt:</strong> 5 kr</p>
<p><strong>Omsättning: 84.349.210 kr</strong></p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>

Fokustema
V85 Åby 14/2
Läs senare
Halina inledde
Hanna Lähdekorpi stod på sidan och fick se sitt sto Halina S.H. vinna V85-1, stodivisionen när Åby arrangerar tävlingarna denna lördag.
(Texten uppdateras)
