
<p class="has-drop-cap wp-block-paragraph">1För fem år sedan vann en amatörtränad, Axevallahäst stayrerloppet Orebro Int’l. Morgan Wilhelmssons <strong>Mack Dragan</strong> (e. Zola Boko) slog till tillsammans med Carl Johan Jepson och plockade hem 400.000 kronor. I eftermiddag i Örebro (första start 14.45) kan det vara dags för en ny häst, tränad av en Axevallaamatör och körd av Jepson, i Orebro Int’l.</p>



<p class="wp-block-paragraph">Det handlar om <strong>Pwojtech Vrijthout</strong> (e. Nuncio), som haft en strålande vinter med sex starter (4-2-0) och höjdpunkten med segern i klass I-finalen på Solvalla för fem veckor sedan. Hästen har inte startat sedan dess.<br>– Fem veckor har ingen större betydelse, han hade startat väldigt tätt innan och vi ville stå bra inne i det här loppet. Distansen är det enda frågetecknet. Hästen är dock jättestark och jättebra i träning så det ska inte vara något problem, men det är det frågetecken jag har, sade tränaren Angelica Jonsson till V65 Direkt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/04/pwojtechvrijthout-617x333.jpg" alt="" class="wp-image-566874"/><figcaption class="wp-element-caption">Angelica Jonssons segerstaplare Pwojtech Vrijthout tillsammans med Carl Johan Jepson och Björn Jansson som står längst till höger på bilden. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Och anledningen till att Angelica laddade mot Orebro Int’l stavas kusken Carl Johan Jepson. <br>– Calle tyckte att vi skulle anmäla, vi hade inte anmält hit om inte Calle hade velat köra honom här, så nu spänner vi bågen lite, sade Angelica.</p>



<p class="wp-block-paragraph">Pwojtech Vrijthout vann klass I-finalen från ledningen och amatörtränare Jonsson sr förstås gärna hästen i den positionen igen.<br>– Även om man upplever honom som trött till slut, så ska det mycket till för att han ska ge sig från ledningen. Han är en hård sort, sade Angelica.</p>



<p class="wp-block-paragraph">Pwojtech Vrijthout ägs bland annat av Angelicas sambom, hovslagaren Björn Jansson.<br><a href="https://sulkysport.se/fokus/internationellt-fynd-bast-i-intl/" target="_blank" rel="noreferrer noopener">Läs mer om Björn här!</a></p>



<p class="wp-block-paragraph"><strong>Senaste vinnarna i Orebro Int’l</strong><br><em>År, vinnare (far) – Körsven (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2019 <strong>Mack Dragan</strong> (e. Zola Boko) – Carl Johan Jepson (Morgan Wilhelmsson) – 1.13,8/3.160</li>



<li>2020 <strong>Electrical Storm</strong> (e. Make It Happen) – Mattias Djuse – 1.14,3/3.160</li>



<li>2021 <strong>Moni Viking</strong> (e. Maharajah) – Björn Goop (Jan Lyng) – 1.13,6/3.180</li>



<li>2022 <strong>Facon Eye</strong> (e. Father Patrick) – Erik Adielsson (Thor Borg) – 1.15,4/3.140</li>



<li>2023 <strong>Versace Face</strong> (e. Joke Face) – Örjan Kihlström (Daniel Redén) – 1.14,7/3.160</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/04/27v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till V75-tävlingarna i Örebro.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2V75 i Örebro spetsas med rejäl jackpot, där det ligger nästan 20 miljoner kronor extra i sjurättspotten. Vägen mot miljonerna går bland annat via en italienska som gör comeback på svensk mark enligt Sulkysports tipsexpert:</p>



<p class="wp-block-paragraph"><em>”Jackpotomgångarna duggar tätt på såväl V86 som V75. Idag är det kryddat i sjurättspotten när lördagscirkusen rullar vidare till Örebrotravet och vi försöker gå lite utanför boxen och finna roliga lösningar för att få upp spelvärdet på omgången.<br>Spikarna blir två till antalet och de kommer i ”mellanavdelningar”. I ett flerklasslopp där många lär sprida strecken chansar vi och tar ställning för <strong>Keyword</strong> (V75-4) med tro att han ska kunna leda från start till mål.<br>Kompletteringsspiken blir <strong>Dana Ek</strong> (V75-5) som dels tjusade oss i höstas, men som vi därtill sett i ett banjobb från Milano.”</em></p>



<p class="wp-block-paragraph">Så här säger Alessandro Gocciadoro själv om Dana Ek:<br>– Hon fick en lugn vinter innan vi började träna igång igen. Hon gick ett snabbjobb ihop med Bengurion Jet för en månad sedan och var väldigt, väldigt bra den dagen. Hästen är i bra form direkt och kommer prestera på en hög nivå, säger Alessandro Gocciadoro.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-27-april/" target="_blank" rel="noreferrer noopener">––> Här är stora tipsgenomgången till dagens V75-jackpot med analyser, spetsbud, sprikar, drag och ranking av alla hästar.</a></p>



<p class="wp-block-paragraph">Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-04-27_32_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-04-27_32_5">Sulkysport V75 – 15 andelar á 150 kr/styck</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/2021/07/chablisribb1-617x333.jpg" alt="" class="wp-image-188290"/><figcaption class="wp-element-caption">Chablis Ribb. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3En femfaldig storloppsfinalist lägger tävlingsskorna på hyllan. Nu väntar ett nytt liv för Josefine Ivehag-tränade sjuåringen <strong>Chablis Girl</strong> (e. Raja Mirchi-Grape Ribb), 1.10,1ak/1.727.300 kr.<br>– Tack för alla fantastiska stunder, insatser, segrar och upplevelser, Chablis. Den överlägset finaste hästen jag tränat hittills under min tränarkarriär! Nu får du välförtjänt lägga tävlingskarriären på hyllan och bli mamma, skriver Josefine Ivehag på sin facebooksida.</p>



<p class="wp-block-paragraph">Största segern kom i ett femåringslopp för ston under Halmstads Sprintermästarweekend 2022 tillsammans med Magnus A Djuse värd 200.000 kronor.<br>Josefin var delägare när Chablis Ribb leasades från uppfödaren Ulf Eliasson (Ribbingstorps Stuteri) under tävlingskarriären, som inleddes hos Leif Witasp. Där slutade stoet trea i långa E3 och kvalade även in till korta E3 och Svenskt Trav-Oaks. Som fyraåring kom hon till Ivehag och kvalade in till Stochampionatet på hemmaplan. Hon var också finalist i Breeders Crown som fyraåring.<br>Totalt gjorde Chablis Ribb 46 starter (8-4-7).</p>



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



<p class="has-drop-cap wp-block-paragraph">4Fyraåringsloppet H.M. Konungens Pokal för kallblod i Norge avgjordes för första gången 1903 och blott en svenskfödd fyraåring har vunnit. 2018 segrade Jan-Olov Persson-tränade <strong>Tekno Eld</strong> (e. Tekno Odin) och Ulf Ohlsson.</p>



<p class="wp-block-paragraph">I eftermiddag på Bjerke avgörs årets upplaga med 175.000 norska kronor till vinnaren. Då blir det årsdebut för kullens kung <strong>Overvik Prinsen</strong> (e. Will Prinsen) – drottningen i kullen är svensk, Jan-Olov Persson-tränade <strong>Majblomster</strong> (e. Tekno Odin), som redan vunnit sin årsdebut – som gick obesegrad genom treåringssäsongens nio starter, inklusive Kriteriet både på Dannero och Bjerke.</p>



<p class="wp-block-paragraph">Den av Frode Hamre tränade hingsten har inte startat sedan han vann Biris Uppfödningslopp i slutet av september. <br>– Han verkar stark och fin, och har lagt på sig mycket och blivit starkare i vinter. Han fick gå i tryckvagn fyra månader innan vi började köra snabbare med honom, har Frode Hamre berättat om vinterträningen i Trav- og Galopp-Nytt.<br>Overvik Prinsen skulle ha årsdebuterat på Biri i början av april, men loppet ställdes in på grund av för få anmälda. Istället har han travat 1.25/2.100 meter i jobb, enligt Hamre i TGN.</p>



<p class="wp-block-paragraph">En svensktränad häst finns med i storloppet. Jan Ove Olsen reser västerut med <strong>Ängsmodde</strong> (e. B.W.Modde) och tar även med sig elvaårige <strong>Verdals Torden</strong> (e. Alm Viktor) till ett sprinterlopp.</p>



<p class="wp-block-paragraph"><strong>Startlista H.M. Konungens Pokal</strong><br><em>2.100 meter autostart, förstapris: 175.000 norska kronor:</em></p>



<ol class="wp-block-list">
<li><strong>Brenne Braute</strong> (e. Bork Odin) – Åsbjörn Tengsareid (Öystein Tjomsland)</li>



<li><strong>Kringelandkyro</strong> (e. Bork Odin) – Johan Kringeland Eriksen</li>



<li><strong>Ängsmodde</strong> (e. B.W.Modde) – Jan Ove Olsen</li>



<li><strong>Bokli Leo</strong> (e. Galileo) – Geir Flåten</li>



<li><strong>Overvik Prinsen</strong> (e. Will Prinsen) – Vidar Hop (Frode Hamre)</li>



<li><strong>Will Nick</strong> (e. Bork Odin) – Eirik Höitomt (Johan Kringeland Eriksen)</li>



<li><strong>Björli Bolt</strong> (e. Tekno Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li><strong>Troll Sterk Faksine</strong> (e. Tekno Odin) – Jan Roar Mjölneröd</li>
</ol>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/04/bj240427baneprogram.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till alla lopp på Bjerke idag.</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/2024/04/furiesrain-617x333.jpg" alt="" class="wp-image-577030"/><figcaption class="wp-element-caption">Furies Rain. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Örebro står för huvudanrättningen denna travlördag medan enklare förrätt och efterrätt serveras i Halmstad (första start 11.10) och Östersund (start 18.30), där det står breddlopp på menyn på båda banorna.</p>



<p class="wp-block-paragraph"><strong>Furies Rain</strong> (e. Muscle Rain), som är lillebror till fyrfaldiga miljonärskan <strong>Ganga Bae</strong>, hade goda unghästmeriter med tredjeplatsen i långa E3 och fjärdeplatsen i Breeders Crown-final som fyraåring, men sedan dess har det varit tunnsått med framgångar.<br>Hästen såldes till Finland efter dyraåringssäsongen och tävlade hos ett par tränare där, innan han i februari vände åter till Sverige och Christoffer Erikssons stall. Efter en fjärdeplats i debuten u ny regi jagar hästen nu startpoäng i Halmstads breddlopp tillsammans med Tord R Salte. Furies Rain är även anmäld till start i Åmål på onsdag.</p>



<p class="wp-block-paragraph">I Östersund kompletteras åtta breddlopp med ett B-tränarlopp med 35.000 kronor i förstapris. Där för Hans Svedin-tränade <strong>Vixi Garbo</strong> (e. Devious Man) årsdebut efter att ha avslutat fjolåret med två segrar och två tredjeplatser i höstens sista fyra starter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/04/240427.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Tvååriga stoet <strong>Mango Mearas</strong> (e. Googoo Gaagaa) har stam som förpliktigar och är lillasyster till exempelvis <strong>Guzz Mearas</strong>, 4,4 miljoner, och <strong>Fortune Mearas</strong>, 1,9 miljoner. Hennes mormor Dame Lavec är mor till elithingsten Raja Mirchi och Sprintermästaren Lavec Kronos. Ikväll på Traveras sedvanliga lördagsauktion bjuds Mango Mearas ut till försäljning.</p>



<p class="wp-block-paragraph">Nio starthästar är bland de 22 hästarna som bjuds ut, däribland <strong>Needle’em</strong> som vunnit två lopp i vinter. Dessutom finns ett tvåårigt kallblod (e. B.W.Modde), en ettåring efter S.J.’s Caviar) och sju fölston i den digitala katalogen. En livstids betäckningsrätt i Flocki d’Aurcy och årsbetäckningar i Bird Parker och Raja Mirchi säljs också.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se alla hästar som bjuds ut och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 I dagarna har <strong>Iwalu</strong> (e. Going Kronos-Bahama), 1.13,2ak/235.560 kr, nedkommit med en dotter efter Propulsion på Sturelunds Gård. Äger gör Grönviks Racing med flera.</p>



<p class="wp-block-paragraph">– Det var moderns första avkomma, berättar Lars Angelhammar, som också avslöjar att Fourth Dimension blir nästa partner för stoet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/04/iwalu-617x692.jpg" alt="" class="wp-image-576875"/></figure>



<p class="wp-block-paragraph">Italienska modern <strong>Bahama </strong>(e. Coktail Jet) har varit en plusvariant i avelsboxen med avkommor som avelshingsten och Grupp I-vinnaren <strong>Farifant </strong>(e. And Arifant), 1.09,7ak*/6.437.625 kr, <strong>Grand Armee</strong> (e. Muscles Yankee), 1.12,1/€259.245, <strong>Denver </strong>(e. Andover Hall), 1.11,0ak/1.204.271 kr, och<strong> Laval</strong> (e. Daguet Rapide), 1.12,0/€98.755.</p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Morgonsvepet
Läs senare
Repris för Axevallaamatör?
Klassklättrarens elddop i Orebro Int'l. Bronshäst i jobb med Bengurion Jet. Femfaldig storloppsfinalist går till avel. Fjolårets treåringskung gör årsdebut. E3-trea i breddlopp.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
