
<p class="has-drop-cap wp-block-paragraph"><strong>1Philip Ess</strong> (2018), <strong>Nordsjö Odin</strong> (2019), <strong>Havglimt</strong> (2020), <strong>Tangen Bork</strong> (2021), <strong>Tangen Minto</strong> (2022), <strong>Bore Mikkel</strong> (2023), <strong>Frivoll Gorm</strong> (2024) och <strong>Tangen Martin</strong> (2025). Där har ni Öystein Tjomsland osannolika segersvit i Svenskt Kallblodsderby. Hur ska någon kunna stoppa den i årets upplaga i Östersund (första start 14.35)?</p>



<p class="wp-block-paragraph">Robert Skoglund har inte gett slaget förlorat på förhand med favoriten <strong>Ängsrask</strong> (e. Bork Odin), som utan att tveka tog innerspår med när han fick välja spår först inför finalen.<br>– I sista jobbet vi körde igår (läs: torsdag) var han väldigt fin, väldigt harmonisk och mjuk och smidig. Vi har gjort det vi kan och det är bara kul nu. Vi drog boll ett och spår ett var givet. Det är närmaste vägen till mål. Vi hoppas att vår är så häst är så startsnabb att han kan hålla ledningen, och det tror jag också, sade Robert Skoglund till V65 Direkt.</p>



<p class="wp-block-paragraph">Ängsrask är favorit på V85-spelet på lördagsmorgonen, medan det stora svenska hoppet <strong>Tekla</strong> (e. Tekno Odin) är andrahandare bakom Öystein Tjomslands <strong>Skeie Ylva</strong> (e. Bork Odin) i Derbystoet. Tekla svarade för en finfin insats i Derbykvalet och tränaren Sandra Eriksson var helnöjd efteråt. <em>”Hon är vacker som en tavla och snabb som en Ferrari.”</em></p>



<p class="wp-block-paragraph">Nu är sista förberedelserna gjorda och…?<br>– Hon gör sällan några fel och är en häst som lärt mig mycket också. Hon var fin senast i kvalet. Det är det här loppet som har varit målet hela året och peppar peppar så känns det som att vi lyckats pricka formen, säger Sandra Eriksson till Kanal75.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/11/jonssonalfisulkyn3-617x333.jpg" alt="" class="wp-image-122855"/><figcaption class="wp-element-caption">Alf Jonsson. Foto Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Kanske kan det bli blågula segrar i eftermiddag i Östersund? Som första gången norrmännen släpptes in i Svenskt Kallblodsderby 1986.<br>Alf Jonssons <strong>Lundick</strong> (e. Pavjol) vann efter en minst sagt överraskande avslutning. Norska duon <strong>Trons Ruggen</strong> (Egil Flenes) och <strong>Lund Jerker</strong> (Gunnar Eggen) var långt, långt före övriga konkurrenter när det vankades upplopp. Kort före mål kastade sig dock båda hästarna över i galopp och diskvalificerades.</p>



<p class="wp-block-paragraph">En bit där bakom seglade Alf Jonsson fram med sin Lundick, tackade för konkurrenternas galopper och defilerade hem segern i Sveriges största fyraåringslopp för kallblod.<br><em>”Vi var 20–30 meter efter och jag kände mig jätteglad över att kanske kunna bli trea. Men inget av de norska ekipagen ville bli tvåa och det slutade med att båda galopperade över mål och vi fick segern istället. Mitt stora misstag var att följa traditionerna genom att hoppa i tjärnen på innerplan. Det kostade en rejäl förkylning”, </em>berättar Alf Jonsson i boken ”Alf Jonsson: En hästkarls hemligheter”.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/derbyt-de-svenska-hoppen/" target="_blank" rel="noreferrer noopener">Läs Sulkysports stora genomgång inför Svenskt Kallblodsderby och Derbystoet här!</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/dreamminemed2-617x333.jpg" alt="" class="wp-image-881842"/><figcaption class="wp-element-caption">Dream Mine och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Jämtlands Stora Pris har sedan premiären 1995, när <strong>Zoogin</strong> (e. Zoot Suit) slog nybakade Elitloppsvinnaren <strong>Copiad</strong> i en hejdundrande duell, avgjorts över medeldistans med startbil. Löpningsrekordet innehas av Readly Express (e. Ready Cash), som tillsammans med Jorma Kontio travade 1.10,0a/2.140 meter i 2018 års upplaga i ett soldränkt Östersund i juni.</p>



<p class="wp-block-paragraph">Sedan ifjol är loppet flyttat framåt i kalendern till augusti och årets upplaga låter inte skämmas för sig. Här finns världens snabbaste hingst – tillika världens snabbaste svenskfödda travare – genom tiderna i startlistan. Jörgen Westholms Elitloppstvåa, femårige <strong>Dream Mine</strong> (e. Maharajah), gör första starten sedan andraplatsen på Solvalla.<br>– Hästen känns väldigt fin och det är meningen att han ska få en riktig urblåsare. Han ska tävla med skor och kommer att vara ännu vassare till Margareta-Pokalen den 19 augusti. Samtidigt åker vi till Östersund med en positiv känsla, säger Jörgen Westholm till Kanal75.</p>



<p class="wp-block-paragraph">Det väntar tufft motstånd i Jämtlands Stora Pris, främst från tioåringen och 24-faldige miljonären <strong>Don Fanucci Zet</strong> (e. Hard Livin) från Daniel Redéns stall.<br>– Don Fanucci Zet var en tåspets ifrån att spetsa i Mikkeli, men tyvärr kom han inte förbi Diva Ek och Örjan valde sedan att sitta kvar i rygg på henne efter den mycket tuffa öppningen på ett svårsprunget innerspår. Han följde med bakom i mål som trea på fint sätt och var inte tom utan hade tussarna sparade. Han tog resan till Finland bra och ser lika fin ut i jobben som han brukar och jag körde honom i måndags och var riktigt nöjd, säger Daniel redén på sin hemsida <a href="http://reddis.se" target="_blank" rel="noreferrer noopener">reddis.se</a>.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-tips-os-8-aug/">––> Här är experternas tips till Östersunds V85-omgång.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V85_2026-08-08_33_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a><br><a href="https://www.atg.se/butik/spelpoolen/V85_2026-08-08_33_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a><br><a href="https://www.atg.se/butik/simsalabim/V85_2026-08-08_33_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p class="wp-block-paragraph">Östersund (första start 14.35) är ensam på banan i Sverige denna storloppslördag.<br><a href="https://sulkysport.se/wp-content/uploads/2026/08/08v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/apexmmmh260729adamstromstalltz-617x418.jpg" alt="" class="wp-image-883089"/><figcaption class="wp-element-caption">Marcus Melander och Apex inför Hambletonian Stakes. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Meadowlands står i centrum ikväll svensk tid (första start kl. 18.00) och i nio travlopp tävlas det om totalt 2.509.850 dollar – eller cirka 24 miljoner svenska kronor. I Hambletonian Stakes ($1.000.000) väntar 500.000 dollar till vinnaren och sex svensktränade hästar finns med i startlistan och där förhandsfavoriterna heter <strong>Apex</strong> (e. Walner) och <strong>Big Ranger</strong> (e. In Range), vilka båda vann sina försök.</p>



<p class="wp-block-paragraph">14 gånger har det blivit en svensktränade vinnare i Hambletonian Stakes, men tränarna bakom försöksvinnarna har aldrig vunnit: Marcus Melander och Anette Lorentzon.</p>



<p class="wp-block-paragraph">Markus Melander har fyra fjärdeplatser bakom sig i största loppet:<br>– Tanken är att Apex ska gå framåt med loppet i försöket i kroppen. Jag är väldigt nöjd med hur han kommer in i loppet. Det känns som att han är i ordning, säger Marcus om hästen som var tvååringskungen förra året.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/mot-forsta-segern/" target="_blank" rel="noreferrer noopener">––> Läs intervjun med Marcus Melander inför Hambletonian här!</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/skarmavbild20260807kl.10.27.33-617x541.jpg" alt="" class="wp-image-883116"/><figcaption class="wp-element-caption">Big Ranger och Anette Lorntzon. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Anette Lorentzon har testar i Hambletonian två gånger tidigare och <strong>Guardian Angel Ås </strong>(e. Archangel) nådde final, dock utan framgång. I In Range-sonen Big Ranger är förutsättningarna helt andra. Hästen har vunnit tolv av 14 starter, men kom till Lorentzon först i sommar. Där har det blivit tre vinster på lika många starter, Hamboförsöket inkluderat.<br>– Jag hade honom i nästan tre veckor innan vi startade första gången. Big Ranger behövde anpassa sig till vårt sätt att träna. Därför valde jag att ha honom kvar hemma och det gav oss ändå ganska bra tid att lära känna varandra. Han är en väldigt trevlig häst att ha omkring sig. säger Anette Lorentzon.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/skriver-travhistoria/" target="_blank" rel="noreferrer noopener">––> Läs mer om Big Ranger och Anette Lorentzon här!</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/busymisslissysasm260801adamstromstalltz-617x365.jpg" alt="" class="wp-image-880979"/><figcaption class="wp-element-caption">Busy Miss Lissy vinner för Åke Svanstedt. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4I Hambletonian Oaks ($500.000) har sju svensktränade travare tagit sig till final. Svenskfödda <strong>Busy Miss Lissy</strong> (e. Calgary Games) och <strong>Setyoursightshigh</strong> (e. In Range) vann sina respektive försök. Favorit lär bli en annan blågul uppfödning bli. <strong>Nezuko Kamado</strong> (e. Chapter Seven) spurtade starkt till andraplatsen i sitt försök bakom Busy Miss Lissy.</p>



<p class="wp-block-paragraph">För Marcus Melander blev det dramatik i torsdags när Nezuko Kamados kusk Scott Zeron åkte i backen på Yonkers Raceway och skadade sig så illa att han tvingas lämna återbud.<br>Därmed blir det kuskbyte och Yannick Gingras ersätter. Kanadensaren har vunnit Hambletonian Oaks sex gånger förut men saknade uppsittning i år. Här är hans vinnarhästar: <strong>Lifetime Pursuit </strong>(2014), <strong>Wild Honey</strong> (2015), <strong>All the Time </strong>(2016), <strong>Ariana G </strong>(2017), <strong>Manchego</strong> (2018), och <strong>Sorella</strong> 2020.</p>



<p class="wp-block-paragraph"><strong>Totalt startar 45 svensktränade hästar på Hambletonian-dagen – här är alla hästarna: </strong></p>



<p class="wp-block-paragraph"><strong>Lopp 1 – Continentalvictory ($30.000)</strong></p>



<ul class="wp-block-list">
<li>Denarius (e. International Moni) – Nancy Takter</li>



<li>Wishuponastar Deo (e. Six Pack) – Per Engblom</li>



<li>Southwind Chaska (e. Tactical Landing) – Jim Oscarsson</li>



<li>Nuance (e. Greenshoe) – Marcus Melander</li>



<li>Whatarace Hanover (e. Walner) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 2 – New Jersey Sire Stakes ($180.000)</strong></p>



<ul class="wp-block-list">
<li>Presidente (e. Walner) – Nancy Takter</li>



<li>Free Scottie (e. Walner) – Marcus Melander</li>



<li>Easy Down Blonde (e. Walner) – Åke Svanstedt</li>



<li>Lifetime Dreamer (e. Ecurie D) – Åke Svanstedt</li>



<li>Mats (e. Walner) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 4 – Muscle Hill ($50.000)</strong></p>



<ul class="wp-block-list">
<li>Nix Nacken (e. Muscle Hill) – Marcus Melander</li>



<li>Kingmen (e. Walner) – Per Engblom</li>



<li>Ardonne (e. Tactical Landing) – Åke Svanstedt</li>



<li>Inexpressable (e. Walner) – Lucas Wallin</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 6 – New Jersey Sire Stakes ($225.000)</strong></p>



<ul class="wp-block-list">
<li>Orchestra (e. Muscle Hill) – Marcus Melander</li>



<li>Gabriella Beatriz (e. Walner) – Åke Svanstedt</li>



<li>Dandelion Wine (e. Ecurie D) – Åke Svanstedt</li>



<li>Caught Speeding (e. Walner) – Lucas Wallin</li>



<li>Rio de Janeiro (e. Walner) – Nancy Takter</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 7 – Vincennes ($60.000)</strong></p>



<ul class="wp-block-list">
<li>Kilimanjaro Face (e. Googoo Gaagaa) – Lucas Wallin</li>



<li>Bourbonista (e. Face Time Bourbon) – Marcus Melander</li>



<li>Green Pastures (e. Greenshoe) – Marcus Melander</li>



<li>Mr Mouton (e. Chapter Seven) – Åke Svanstedt</li>



<li>Nordic Catcher (e. Six Pack) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 8 – John Cashman Memorial ($281.200)</strong></p>



<ul class="wp-block-list">
<li>Super Chapter (e. Chapter Seven) – Marcus Melander</li>



<li>Aetos Kronos (e. Bold Eagle) – Marcus Melander</li>



<li>French Wine (e. Bar Hopping) – Nancy Takter</li>



<li>Up Your Deo (e. Walner) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 9 – Hambletonian Oaks ($500.000)</strong></p>



<ul class="wp-block-list">
<li>Busy Miss Lissy (e. Calgary Games) – Åke Svanstedt</li>



<li>Nezuko Kamado (e. Chapter Seven) – Marcus Melander</li>



<li>Custom (e. Walner) – Per Engblom</li>



<li>Setyoursightshigh (e. In Range) – Marcus Melander</li>



<li>Lainey W (e. Bar Hopping) – Marcus Melander</li>



<li>Leading Lady (e. Walner) – Nancy Takter</li>



<li>Madam Cheval (e. Walner) – Nancy Takter</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 10 – Dr. John Steele Memorial ($183.650)</strong></p>



<ul class="wp-block-list">
<li>Tactical Moni (e. Tactical Landing) – Marcus Melander</li>



<li>Bravo Angel (e. Readly Express) – Per Engblom</li>



<li>Delaney Hanover (e. Muscle Hill) – Lucas Wallin</li>



<li>Warrawee Michelle (e. Walner) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><strong>Lopp 11 Hambletonian Stakes ($1.000.000)</strong></p>



<ul class="wp-block-list">
<li>Apex (e. Walner) – Marcus Melander</li>



<li>Big Ranger (e. In Range) – Anette Lorentzon</li>



<li>Captain Naughty (e. Captain Corey) – Per Engblom</li>



<li>Magic Punk (e. Wishing Stone) – Åke Svanstedt</li>



<li>Spencer Hanover (e. Chapter Seven) – Marcus Melander</li>



<li>American Power (e. Walner) – Marcus Melander</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/highonpepperjkm260318adamstromstalltz-617x410.jpg" alt="" class="wp-image-828910"/><figcaption class="wp-element-caption">Katja Melkkos High On Pepper håller ifrån sig utvändige Kentucky River på Solvalla i vintras. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Nästa lördag avgörs Åby Stora Pris och i morgon blir startlistan klar till 3.140-metersloppet med 1,5 miljoner kronor till vinnaren färdigställd. Elva hästar är klara i dagsläget – det finns plats för tolv – och den sista deltagaren presenteras i eftermiddag.</p>



<p class="wp-block-paragraph">Senaste hästen in är Katja Melkko-tränade <strong>High On Pepper</strong> (e. Ready Cash). Daniel Redén fick även häromdagen en tredje biljett när årets Prix d’Amérique-trea <strong>Epic Kronos</strong> (e. Muscle Hill) bjöds in. Redén har sedan tidigare Francesco Zet (e. Father Patrick) och <strong>Kentucky River</strong> (e. Father Patrick) i loppet.</p>



<p class="wp-block-paragraph"><strong>Klara för Åby Stora Pris 2026</strong><br><em>Häst (far) – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Charron</strong> (e. Code Bon) – Geir Vegard Gundersen</li>



<li><strong>Epic Kronos</strong> (e. Muscle Hill) – Daniel Redén</li>



<li><strong>Francesco Zet</strong> (e. Father Patrick) – Daniel Redén</li>



<li><strong>Get A Wish</strong> (e. Wishing Stone)– Robert Bergh</li>



<li><strong>High On Pepper</strong> (e. Ready Cash) – Katja Melkko</li>



<li><strong>Ibiki de Houelle</strong> (e. Love You) – Kevin Leblanc</li>



<li><strong>Kentucky River</strong> (e. Father Patrick) – Daniel Redén</li>



<li><strong>Macahan</strong> (e. Maharajah) – Maria Törnqvist</li>



<li><strong>Petho</strong> (e. Propulsion) – Erlend Rennesvik</li>



<li><strong>Phantom Express</strong> (e. Readly Express) – Joakim Elfving</li>



<li><strong>Powwow</strong> (e. Papagayo E.) – Jan Kristian Waaler</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/atlantic1-617x425.jpg" alt="" class="wp-image-839755"/><figcaption class="wp-element-caption">Idao de Tillard omrigad av segerkusken Clément Duvaldestin och skötaren Susanne Ohme. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Det är korta och penningstinna lopp på gång i Argentan idag och den självklara begivenheten är <strong>Idao de Tillards</strong> (e. Severino) närvaro i mileloppet Criterium de Vitesse de Basse-Normandie (€120.000). Ska vi vara uppriktiga så var det länge sedan Thierry Duvaldestins stjärna hade en, på papperet, så pass lätt uppgift framför sig och är allt normalt har Idao de Tillard inga motståndare som är bra nog att utmana om segern idag.</p>



<p class="wp-block-paragraph">Det är kanske mer intressant att spekulera om segertiden i loppet. 1.09,2a/1.609 meter är banrekord i Argentan och löpningsrekord i Criterium de Vitesse de Basse-Normandie, satt av Hohneck ifjol. </p>



<p class="wp-block-paragraph">Det finns även svenska inslag i Argentan idag. I det inledande Prix Hohneck (€27.000) över 1.609 meter startar Ron Kuiper <strong>Utah Southwind</strong> (e. Bold Eagle) som gör andra starten i Frankrike. David Thomain sitter upp från spår två bakom bilen.<br>Matthieu Abrivard kör Elke Frintas <strong>Enjoy The Moment</strong> (e. Propulsion) I samma lopp. Den sjuårige valacken kommer från två raka tredjeplatser på Enghien och börjar idag från spår fyra. Från bakspår startar Maria Törnqvists <strong>Ever So Much</strong> (e. Maharajah) och det är Gabriele Gelormini som sköter tömmarna där.</p>



<p class="wp-block-paragraph">Svenskfödde <strong>Mister Lion</strong> (e. Mister J.P.) provar lyckan i Prix Un Mec d’Heripre (€27.000) över 2.150 meter och har lottats till spår ett bakom bilen.</p>



<p class="wp-block-paragraph"><strong>Startlista Criterium de Vitesse de Basse-Normandie (€120.000)<br></strong>1.609 meter autostart, Argentan lördag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Falco Killer Gar</strong> (e. Varenne) – Theo Duvaldestin</li>



<li><strong>Hulysse Diego</strong> (e. Reve de Beylev) – Jean William Hallais</li>



<li><strong>Inmarosa</strong> (e. Amiral Sasha) – Leo Abrivard</li>



<li><strong>Idao de Tillard</strong> (e. Severino) – Clement Duvaldestin</li>



<li><strong>Ideal Ligneries</strong> (e. Repeat Love) – Anthony Barrier</li>



<li><strong>Jazzman Debailleul</strong> (e. Repeat Love) – Erno Szirmay</li>



<li><strong>Koctel du Dain</strong> (e. Boccador de Simm) – David Thomain</li>



<li><strong>Jingle du Pont</strong> (e. Niky) – Nicolas Bazire</li>



<li><strong>Kash des Caillons</strong> (e. Drole de Jet) – Anthonin Favris</li>



<li><strong>Rikita JP</strong> (e. Mister J.P.) – Matthieu Abrivard</li>



<li><strong>Jeannette Priory</strong> (e. Tag Wood) – Tony le Beller</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/10devilishhill-617x333.jpg" alt="" class="wp-image-588699"/><figcaption class="wp-element-caption">En lucka 50 kvar var segerreceptet för Magnus Teien Gundersen och Devilish Hill (1) i Fyraåringseliten 2024. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7USA-födde valacken <strong>Devilish Hill</strong> (e. Muscle Hill) tog Europa med storm när han i sitt första framträdande vann Fyraåringseliten på Solvalla för två år sedan på 1.09,3a/1.640 meter och vägen mot stjärnorna låg utstakad för Geir Gevard Gundersens travare.</p>



<p class="wp-block-paragraph">Redan som fyraåring tog han också andraplatsen i Ulf Thoresen Grand International på Jarlsberg bakom <strong>Önas Prince</strong> (e. Chocolatier) och vann Ragnar Thorngrens Minne före Sprintermästaren <strong>Crown</strong> (e. Chapter Seven).<br>Ifjol blev det två vinster och en tredjeplats i Oslo Grand Prix, men det riktiga lyftet kom inte. 2026 har hans främsta insatser på fyra starter kommit i monté.</p>



<p class="wp-block-paragraph">Nu ska nya kapitel skrivas i karriären – hästen är nämligen numera tillbaka på andra sidan Atlanten och i träning hos Per Engblom i USA.<br>– Ägaren Kjell Magne Andersen ville gärna prova honom där igen, eftersom Devilish Hill är en bättre häst nu än när han kom till oss. Och Devilish Hill har en teknik som kommer till sin rätt väldigt bra på 800-metersbanor, säger förre tränaren Geir Vegard Gundersen till Trav- og Galopp-Nytt.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Stjärnornas dag i två länder
Svensken som ska bryta monstersviten. Sandras toppsto är redo. Världens snabbaste hingst genom tiderna i Östersund. Marcus och Anette kan skriva Hambohistoria. Alla svenskar på Meadowlands ikväll. En plats kvar i Åby Stora.
Detta och mer bland lördagens ”Sju nyheter vid sju”.
Detta och mer bland lördagens ”Sju nyheter vid sju”.
