
<p class="has-drop-cap">1 I lördags imponerade <strong>Ackuratess </strong>(e. Aperefectyankee-Lina Liv) när det åttaåriga stoet var överlägsen på nytt rekord – 1.11,0a/1.640 meter – i ett försök i Diamantstoet.</p>



<p>Anders Odelros tränar och det är inte bara Ackuratess som vunnit rikstotolopp i familjen. Det har hennes mor, mormor och mormors mor också gjort…och det började med <strong>Eva Jaquette</strong> den 3 december 1988 på Bergsåker och precis som Ackuratess gjorde hon sitt jobb från dödens!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/01/skarmavbild20260120kl.13.10.59-617x425.jpg" alt="" class="wp-image-812564"/><figcaption class="wp-element-caption">Anders Odelros.</figcaption></figure>



<p><strong>Här är den unika (?) rikstotofamiljen:</strong></p>



<ul class="wp-block-list">
<li><strong>Eva Jaquette </strong>(e. Noble Wejover-Oli Jacquette) – Stodivisonen – 3/12 1988</li>



<li><strong>Jaga Jill </strong>(e. J.R. Broline-Eva Jaquette) – Stolopp – 15/3 2003</li>



<li><strong>Lina Liv</strong> (e. Look de Staar-Jaga Jill) – Lärlingslopp – 2/11 2013</li>



<li><strong>Ackuratess</strong> (e. Aperefectyankee-Lina Liv) – Diamantstoet– 19/1 2026</li>
</ul>



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



<p class="has-drop-cap">2 Han är hästen som ordnade Alf Jonssons tränarseger 1.000 i karriären i januari 2021. Ikväll på <strong>Bergsåker </strong>(första start 18.27) gör tioårige <strong>Tekno Jerven </strong>(e. Tekno Odin), 1.21,0ak/2.662.138 kr, comeback efter långt skadeuppehåll och avelsarbete och han gör det i Öystein Tjomslands regi.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/teknojervenjj-617x333.jpg" alt="" class="wp-image-661949"/><figcaption class="wp-element-caption">Tekno Jerven och Jimmy Jonsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Tekno Jerven har inte startat sedan början av april förra året, då han besegrade kallblodseliten med hästar som <strong>Oppgårdsdrängen </strong>(e. Tekno Odin), <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.), <strong>B.W.Sture</strong> (e. Moe Odin) och <strong>Järvsöodin</strong> (e. Järvsöfaks). Siktet var inställt på Elitkampen i maj, men skada satte stopp för hästen som ägs av Alf.</p>



<p>– Tekno Jerven fick en gaffelbandsskada och fick vila länge. Han var ett halvår hos Fredrik Fransson och körde lite avelsverksamhet samtidigt, säger Jimmy Jonsson till Kanal75. </p>



<p>Hästen återkom till Tjomsland i slutet av sommaren.</p>



<p>– Han har tränat på och han har många jobb i sig. Som snabbast har han gått 1.27 i ett banjobb på Bergsåker och det har gjort honom gott. Han känns fräsch och fin och löpsugen, men är fortfarande lite tung i kroppen. Så jag skulle tro att han behöver ett par lopp i kroppen innan han är som bäst, säger Jimmy till Kanal75.</p>



<p>Bland motståndarna i återkomsten finns Oppgårdsdrängen och <strong>Solhöjdens Drake</strong> (e. Lome Brage), som båda varit igång och tävlat i vinter.</p>



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



<p class="has-drop-cap">3 <strong>Solvalla</strong> (första start 18.40) delar kvällens expresstrav med V86 med Bergsåker. Johan Untersteiner-tränade <strong>Steady Express</strong> (e. Readly Express) fick sin segerrad bruten efter nio raka triumfer på Solvalla annandag jul, men ett år äldre storebrodern <strong>Steady King</strong> (e. S.J.’s Caviar) kan bygga vidare på sin svit.</p>



<p>Fyra raka vinster ståtar han med inför dagens uppgift, där Örjan Kihlström hoppar upp i vagnen bakom Untersteiners sexåring. Spår fyra bakom bilen i ett försök i mellanklassen av Solvallaserien är uppgiften för Steady King, som vunnit sju av tio starter i karriären.</p>



<p>Några hästar av god silverdivisionsklass dyker upp i lopp utanför V86-kupongen på båda banorna. På Solvalla möts <strong>Nouri di Quattro</strong> (e. Southwind Frank) och <strong>Nephtys Boko </strong>(e. Trixton), medan Bergsåker bjuder på stallkamp från Daniel Wäjersten med trion <strong>Kingen Mearas </strong>(e. Chapter Seven) – tilllbaka efter två starter på Vincennes – <strong>Zaxton </strong>(e. Trixton) och <strong>August Zonett </strong>(e. Pojke Kronos).</p>



<p>Vid lunchtid kommer Sulkysports expertpanel med sina bästa spikar och skrälldrag till kvällens V86-omgång.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/01/21v86.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/01/21v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/11/varennemal23-617x333.jpg" alt="" class="wp-image-119828"/><figcaption class="wp-element-caption">Varenne är den enda europafödda travaren som lyckats bli invald i Living Hall of Fame i USA. Foto Stefan Melander/stalltz.se</figcaption></figure>



<p class="has-drop-cap">4 I måndags kunde Sulkysport berätta att Stefan Melanders stjärna <a href="https://sulkysport.se/nuncio-prisad-i-usa/" data-type="link" data-id="https://sulkysport.se/nuncio-prisad-i-usa/" target="_blank" rel="noreferrer noopener">Nuncio</a> (e. Andover Hall-Nicole Isabelle), 1.08,7ak/28.810.230 kr, valts in till Living Horse Hall of Fame vid Harness Racing Museum &#038; Hall of Fame.</p>



<p>Det hör inte till vanligheterna, att en häst som tränats i Europa dyker upp i de här sammanhangen, men det har hänt tidigare också. Stig H Johansson-tränade <strong>Peace Corps </strong>(e. Baltic Speed-Worth Beein), 1.10,1ak*/24.910.670 kr, valdes in 1999.</p>



<p>Både Nuncio och Peace Corps är USA-födda, men en häst född i Europa har faktiskt också tagit plats i Living Horse Hall of Fame. Italienskfödde <strong>Varenne </strong>(e. Waikiki Beach-Ialmaz), 1.09,1ak*/52.086.757 kr, som tränades av Jori Turja valdes in 2010.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/colbertdamauktindeauvillekopia-617x411.jpg" alt="" class="wp-image-626466"/><figcaption class="wp-element-caption">Auktionshallen i Deauville. Foto: stalltz.se</figcaption></figure>



<p class="has-drop-cap">5 Idag drar Arqana Trots Prix d’Amérique-auktionen igång i Deauville!<br>Några nya namn har tillkommit i auktionskatalogen, men de säljs först under andra dagen – på fredag på Vincennes.</p>



<p>En av dem är sjuåriga stoet <strong>Jewelcandle Fac </strong>(e. Prodigious-Thebaide), 1.10,6am/€350.600, som vunnit semi-classique-löpningen Prix Henri Levesque (€120.000) och slutat tvåa i Grupp I-klassade Prix Jag de Bellouet och trea i Prix de Cornulier.</p>



<p>En annan är nyblivna treåriga stoet <strong>Nouba du Bas Bosq </strong>(e. Galius-Turquoise de Ry), 1.15,3l/€67.875, som startat sex gånger (4-0-0) i regi Philippe Allaire och bland annat vunnit Grupp III-loppet Prix Marcel Dejean (€54.000) och Prix Undina (€51.000) på Vincennes.</p>



<p><a href="https://www.arqana-trot.com/catalogue/ventes-du-prix-d-amerique-2026/229" data-type="link" data-id="https://www.arqana-trot.com/catalogue/ventes-du-prix-d-amerique-2026/229" target="_blank" rel="noreferrer noopener">Auktionshästarna hittar ni här.</a></p>



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



<p class="has-drop-cap">6 En svensktränad travare dyker upp på fransk mark idag. I <a href="https://www.letrot.com/courses/programme/2026-01-21/7616" data-type="link" data-id="https://www.letrot.com/courses/programme/2026-01-21/7616" target="_blank" rel="noreferrer noopener">Mauquenchy </a>(första start kl. 10.57) årsdebuterar Jörgen Westholms <strong>Mystic des Thuyas</strong> (e. Hohneck) i Prix de la Cathedrale de Rouen (€18.000) över 2.150 meter autostart.</p>



<p>Mystic des Thuyas körs av Franck Ouvrie och fyraåringen jagar andra raka segern – ifjol avslutade Mystic des Thuyas året med vinst i Prix Olivoyages (€14.000) i Mauquenchy.</p>



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



<p class="has-drop-cap">7 Stjärnorna i Frankrike verkar ha det tufft för tillfället och för familjen Bazire har det varit extra tungt på sistone både på den två- och fyrbenta sidan. I måndags meddelades att <a href="https://sulkysport.se/missar-pda-sasongen-ar-over/" data-type="link" data-id="https://sulkysport.se/missar-pda-sasongen-ar-over/" target="_blank" rel="noreferrer noopener">Jushua Tree</a> är skadad och missar Prix d’Amérique.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/hubbleduvivier-617x333.jpg" alt="" class="wp-image-731282"/><figcaption class="wp-element-caption">Hubble du Vivier och Jean Michel Bazire kom in på upploppet i ledning på innerspår och avslutade det som vinnare i tredjespår. Foto Gerard Forni</figcaption></figure>



<p>Nu meddelar Nicolas Bazire i Paris-Turf, att <strong>Hubble du Vivier</strong> (e. Vulcain du Vivier-Minnie du Vivier), 1.09,8am/€578.500, lägger tävlingsskorna på hyllan.</p>



<p>Fyra starter under årets vintermeeting har utmynnat i två segrar och ett andra- och tredjepris. Den nioårige valacken står med två raka triumfer – Prix de Chateaudun (€90.000) och Prix du Forez (€90.000) – och en andraplats i finalen i Grand National du Trot och ett tredjepris i Prix de Montignac-Charente.</p>



<p>– Han har ett allvarligt senproblem i ett framben och med tanke på hans höga ålder innebär detta att hans karriär tyvärr är över, säger Nicolas Bazire till Paris-Turf.</p>



<p>Totalt har karriären inbringat tolv segrar. Bland tidigare triumfer kan också Prix de New York (€90.000) på Enghien nämnas.</p>

Fokustema
Sju nyheter vid sju
Läs senare
En unik fyrling?
Kallblodsstjärna tillbaka efter skada. Förlänger segerraden? Varenne ensam europé. Fransk topphäst slutar. Prix d'Amérique-auktionen slår upp portarna.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
