
<p class="has-drop-cap">1 Solvalla, Jägersro och Bergsåker var först ut. Den 8 mars 1936 var det premiär för travtävlingar på landbacken i Östersund när <strong>Östersundstravet</strong> blev landets fjärde bana. Ikväll (första start 18.20) firas 90-årsjubileum på jämtlandsbanan.</p>



<p><strong>Jämtlands Travsällskap</strong> hade bildats redan 1883, men banan på landbacken dröjde. Bygdens starke man Sven O Persson var en av de stora initiativtagarna när travbanan byggdes. Åren 1936 till 1971 var Sven O Persson ordförande i Jämtlands Travsällskap. Dessutom var han under en period ordförande och även vice ordförande i Svenska Travsportens Centralförbund.<br>Vid sidan om sitt stora företagande var affärsmannen Sven O Persson både uppfödare, hästägare, tränare och körsven.</p>



<p>Om premiärdagen den 8 mars 1936 berättas i Östersundstravets jubileumsbok när banan firade 75 år 2011:<br>”<em>Det var en ganska spartan travbana som togs i bruk. Måldomartorn, mittorn och totalisatorbodar hade flyttats upp från istravet, men var inte uppfräschade och såväl inner- som ytterplan var rena stubbåkern. Men själva travbanan var det inget fel på! Det var en mycket modern och riktig travbana med doserade kurvor</em>.”</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/heijvorostersundstravet75ar-617x439.jpg" alt="" class="wp-image-824998"/><figcaption class="wp-element-caption">Heijvor och Olov Halvarsson vann det allra första loppet på Östersundstravet, den 8 mars 1936. Foto Östersundstravet 75 år</figcaption></figure>



<p>Det allra fösta loppet vanns av treåriga kallblodsstoet <strong>Heijvor</strong> med Olov Halvarsson och när första säsongen var avverkad stod <strong>Erik Pettersson</strong> som segerrikaste kusk och banans första champion med 17 segrar.</p>



<p><strong>Einar Magnusson</strong> är Östersundstravets framgångsrikaste kusk genom åren och Einar, som fortsatt är en trogen gäst vid tävlingarna, tog hem championatet 15 gånger. Han blev också Östersundstravets förste medlem i tusenklubben, där han några år sedan fick sällskap av <strong>Jan-Ivan Eriksson</strong>. Totalt vann Einar 1.511 lopp.</p>



<p><strong>Ulf Ohlsson</strong> har tagit 13 championat, medan <strong>Axel Johnsson</strong> – dominant på 1950- och 1960-talet – tog dussinet fullt.</p>



<p>I banprogrammet till kvällens tävlingar berättas många historier om människor och hästar i travbanans historia – <a href="https://cdn.travsport.se/racecards/trot/sport/616164.pdf" target="_blank" rel="noreferrer noopener">läs mer här!.</a></p>



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



<p class="has-drop-cap">2 Jubileumstävlingarna i <strong>Östersund</strong> (första start 18.20) bjuder på tio lopp och högsta prissumman finns i Bertil Bäckmans Minne i dubbelcupen för kallblod. </p>



<p>Bertil Bäckman tog över ordförandeklubban efter Sven O Persson och var ordförande i Jämtlands Travsällskap från 1971 till 1990. Bertil var både vice ordförande i Svensk Travsports Centralförbund och i ATG:s styrelse. 1990 tilldelades han som fjärde person i historien Svensk Travsports Stora Hederstecken och i Norge fick han Det Norske Travsällskapets Hederstecken.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2020/05/jomarblekkan-617x333.jpg" alt="" class="wp-image-92690" style="width:561px;height:auto"/><figcaption class="wp-element-caption">Jomar Blekkan. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p><strong>Jomar Blekkan </strong>blev 1994 den andre utländske kusken att bli champion på en svensk bana – Tryggve Diskerud var först ut i Årjäng 1963 – när han tog sin första av fem titlar i Östersund. I Bäckmans Minne kör han en riktig segermaskin i <strong>Skjegge Svarten</strong> (e. Dotterud Teddy) med 21 segrar på 55 försök och fyra raka triumfer i resultatraden inför kvällens start. Tillägg på sprinterdistans är uppgiften som ska lösas för att bilda staket i raden.</p>



<p>Fast Jomar har redan en häst med den resultatraden – fyraårige kallblodet <strong>Valle Kodin</strong> (e. Moe Odin) gästar Östersund för första gången efter att ha inlett karriären med fem vinster på lika många starter hemma på Orkla Arena.</p>



<p>Denne kommer ut i jubileumsloppet för kallblod, som precis som varmblodens jubileumslopp är öppna för hästar med högst 90 tusenlappar på kontot.</p>



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



<p class="has-drop-cap">3 15 starter och noll segrar 2025. Tre starter och tre segrar 2026! Örebroamatören Johannes Dennemans sto <strong>O.M.Keep On Runnin</strong> (e. Quite Easy) har hittat tillbaka till vinnarspåret igen efter lite av en mellansäsong förra året.</p>



<p>Idag på lunchbanan Romme (första start 12.20) dyker hon upp med den snygga resultatraden, men frågan är om segerformen sitter i även framför sulky? Årets tre segrar har nämligen alla tagits i montédisciplinen med Sofia Adolfsson i sadeln.</p>



<p>Senaste sulkysegern kom på just Romme i december 2024 med Jorma Kontio i vagnen. Idag är Magnus A Djuse kusken som ska förlänga segersviten.</p>



<p>Motstånd saknas verkligen inte när Katja Melkko årsdebuterar fyraåriga <strong>My Creation</strong> (e. Hohneck), som hade en finfin treåringssäsong med fem vinster på elva försök och segrar i bland annat Sikta Mot Stjärnorna och Dalatravet Rommes Treåringspris, men saknade framgångar i insatsloppen. Den enkla anledningen – hon var inte anmäld. I år finns ett storlopp att sikta mot, nämligen Derbystoet i höst där My Creation står kvar i anmälningsrullorna.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/03/260306.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens 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/2019/03/lionelml3-617x333.jpg" alt="trav, travsport, sulkysport, startlistor, v75, v86, gs75" class="wp-image-40048"/><figcaption class="wp-element-caption">Lionel vid seger i ett Elitloppsförsök 2018. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4 <strong>Pär Pergenius</strong>, trogen hästskötare sedan 15 år tillbaka hos Solvallatränaren Daniel Redén, kommer att lämna travet och avslutar sin anställning hos Redén inom kort. Pär Pergenius började hos Redén 2011 och blev så småningom synonym med hästar som <strong>Shaq Is Back</strong> (e. Credit Winner), <strong>Traveling Man</strong> (e. Supergill), <strong>Lionel</strong> (e. Look de Star) och <strong>Perfect Spirit </strong>(e. Andover Hall).</p>



<p>Pär och hans tidigare skolkamrat Michaela Magnusson (fortfarande anställd hos Stall Zet) är de två hästskötare som tillbringat längst tid hos Redén, men nu tar det alltså slut för Pergenius, som dock låter syster Lina jobba vidare i stallet. Uppgiften kommer från Zet-podden och hemsidan reddis.se. </p>



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



<figure class="wp-block-image size-sulky-liten2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/03/skarmavbild20260305kl.21.57.16-350x354.jpg" alt="" class="wp-image-824980" style="width:400px;height:auto"/><figcaption class="wp-element-caption">Expo i Pennsylvania med flera sulkyhästar i deltagarlistan.</figcaption></figure>



<p class="has-drop-cap">5 Vad händer med en amerikansk topphäst efter avslutad sulkykarriär? Ja, det beror förstås på. Handlar det om ett sto så brukar avelsarbete stunda, eller om en manlig krabat lyckats riktigt väl så kan det bli samma sak där; avelsjobb.</p>



<p>Men det finns som bekant också en himla massa valacker som förgyller världens travlopp och en mycket framgångsrik sådan var <strong>Sevruga</strong> (e. S.J.&#8217;s Caviar), som för Julie och Andy Miller vann massor av betydelsefulla lopp och som totalt tjänade 1.217.021 dollar.</p>



<p>Idag, igår och två dagar framåt, kommer Sevruga att vara en av flera sulkyhästar som visas upp vid <strong>Horse World Expo</strong> i Pennsylvania Farm Show Complex, alltså i samma lokaler där den berömda Harrisburg-auktionen hålls varje höst. </p>



<p>Och det är inte första gången Sevruga visas upp på Horse World Expo. Valacken, som mer eller mindre skänktes av tidigare ägaren KDM Stables Corp. till tyskan Sabine Springs, som hade förälskat sig i hästen under tiden som tävlingsfunktionär på banan Harrah&#8217;s Philadelphia. Och redan för sex år sedan deltog Sevruga i utställningen i Harrisburg.</p>



<p>Och därifrån till nu så har den 18-årige valacken varit en del av expon, där han visar upp sina konster under sadel för ryttaren Mackenzie Peuterbaugh och så länge Sevruga är frisk och fräsch lär han återkomma till Harrisburg varje vår för att sprida hästatmosfär bland besökarna.</p>



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



<p class="has-drop-cap">6 Enghien i Paris tävlar idag och ett gäng svensktränade hästar tar chansen att vara med i Prix de Noirmoutier (€52.000) över 2.875 meter.</p>



<p>David Perssons duo <strong>Global Enjoy</strong> (e. Explosive Matter) och <strong>Sandokan</strong> (e. Maharajah) är båda med i loppet och den sistnämnde har en vinst på Vincennes att luta sig mot inför dagens uppgift. I vintermeetingets början slog Sandokan till i Prix Melusina (€40.000) och vann på 1.10,8a/2.100 meter för Björn Goop. Idag är det Matthieu Abrivard som sköter tömföringen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/sandokan1-617x333.jpg" alt="" class="wp-image-522524"/><figcaption class="wp-element-caption">David Persson-tränade Sandokan. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Global Enjoy har däremot inte lyckats något vidare i Paris i vinter. Efter två starter jagar hästen första checken och det är Franck Ouvrie som ska försöka jaga in den idag. </p>



<p>Kevin Oscarssons startar <strong>Not For Sale</strong> (e. Readly Express) i samma lopp. Tre vinterstarter i Paris inbringade inte några pengar, men Not For Sale vann lopp i Lyon i slutet av januari. Idag är det Antonin Andre som sitter i sulkyn.</p>



<p>Jörgen Westholms <strong>Cameron</strong> (e. Maharajah) har två segrar på nio starter i Frankrike, båda tagna på Vincennes och Westholm har anlitat Alexandre Abrivard till sin häst i dagens uppgörelse.</p>



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



<p class="has-drop-cap">7 Ledningen för <strong>Illinois Harness Horsemen’s Association (IHHA)</strong> är försiktigt optimistisk inför den tredje omgången av konkursförhandlingarna kring Hawthorne Race Course, som är planerad till tisdagen den 10 mars inför domare Timothy Barnes vid den federala konkursdomstolen i <strong>U.S. Bankruptcy Court for the Northern District of Illinois, Eastern Division.</strong></p>



<p>Förhandlingarna inleddes med ett möte på sex och en halv timme den 3 mars, följt av en andra session dagen därpå.<br><em>”Jag hoppas att hästmänniskorna kan känna sig uppmuntrade av att domstolen ser till deras intressen,”</em> sade domare Barnes.</p>



<p>Domaren anser att ägare, tränare och kuskar som väntar på prispengar från förra hösten bör klassas som en ”critical vendor<strong>”</strong>, en prioriterad fordringsägare, samma kategori som banans anställda benämns under.<br><em>”Detta är en mycket uppmuntrande utveckling och ett viktigt steg för att säkerställa att hästmänniskor får betalt,</em>” skrev IHHA på sin webbplats.</p>



<p>Med domare Barnes godkännande hoppas Hawthorne kunna använda en kreditlina på <strong>16 miljoner dollar</strong> i så kallad <strong>debtor-in-possession-finansiering</strong> från riskkapitalgivaren <strong>JDI Loans</strong>.</p>



<p>Den budget som Hawthorne har lagt fram i konkursdomstolen innebär att banan ska betala <strong>1,4 miljoner dollar</strong> i studsade checkar till hästfolket samt ytterligare <strong>2,4 miljoner dollar</strong> i obetalda prispengar.</p>



<p><strong>Illinois Racing Board</strong> suspenderade licensen för Hawthornes travmeeting Suburban Downs den 26 januari efter att checkar hade studsat i december och januari. Samtliga 14 tävlingsdagar under årets meeting, som började i november, fick därför ställas in.</p>



<p>Även om både trav- och galopptävlingar arrangeras av banan, som ägs av familjen Carey sedan 1909, betraktas galoppmeetinget som en separat verksamhet av Racing Board och påverkas därför inte av avstängningen av Suburban Downs, allt enligt Neil Milbert på harnessracingupdate.com.</p>



<h2 class="wp-block-heading">Många fordringsägare väntar på pengar</h2>



<p>Före konkursansökan den 27 februari trodde man allmänt att Hawthorne hade ett begränsat antal fordringsägare – bland annat medlemmar i IHHA, <strong>Illinois Thoroughbred Horsemen’s Association (ITHA)</strong>, <strong>Churchill Downs, Inc.</strong>, några simulcast-operatörer samt två entreprenörer från Chicago som arbetade med rivningen av en del av läktaren 2020 inför den tilltänkta ombyggnaden till ett racino.</p>



<p>Men konkursansökan visar att fordringsägarna finns över hela USA och att skuldbeloppen är mycket stora.</p>



<p>Handlingarna visar tillgångar på mellan <strong>50 och 100 miljoner dollar</strong> och skulder på mellan <strong>100 och 500 miljoner dollar</strong>.</p>



<p>Banans fastigheter uppskattas vara värda <strong>95 miljoner dollar</strong>. Mark och racerbanan ägs av <strong>Carey Heirs Properties, LLC</strong>, som består av 77 familjemedlemmar – ättlingar till Thomas Carey, som köpte banan 1909 (18 år efter att den byggdes).</p>



<p>”Häpnadsväckande!” sade IHHA:s verkställande direktör <strong>Tony Somone</strong>, och det var den spontana reaktionen efter att omfattningen av Hawthornes skulder blev känd i konkursdomstolen.</p>



<p>De 20 största oprioriterade fordringsägarna har tillsammans fordringar på över <strong>37 miljoner dollar</strong>, varav mer än <strong>16 miljoner</strong> kommer från aktörer inom hästsporten.</p>



<p>Hawthornes största oprioriterade fordringsägare är dess tidigare partner inom sportspel, <strong>Fanatics</strong>, som har en fordran på omkring <strong>9 miljoner dollar</strong>.</p>



<p><strong>Ariza Group Architects</strong> kräver mer än <strong>5,6 miljoner dollar</strong>, och <strong>W.E. O’Neil Construction</strong> nästan <strong>5,1 miljoner dollar</strong> (ett krav som Hawthorne bestrider). Båda är Chicago-baserade företag som anlitades i förberedelserna för det planerade <strong>44-miljoners racino-projektet</strong>, vilket stannade av efter rivningsarbetena.</p>



<p>Hawthorne är dessutom skyldig <strong>Horse Racing Integrity and Safety Authority</strong> <strong>971.208 dollar</strong>.</p>



<h2 class="wp-block-heading">På listan över fordringsägare kopplade till simulcast-verksamheten finns bland annat:</h2>



<ul class="wp-block-list">
<li><strong>Monarch Content Management</strong> (Stronach-gruppens simulcastbolag) – krav på <strong>7,1 miljoner dollar</strong></li>



<li><strong>Roberts Communications Network</strong> (kostnader för att sända och ta emot simulcast-signaler) – <strong>1,5 miljoner dollar</strong></li>



<li><strong>Woodbine</strong> – <strong>1,2 miljoner dollar</strong></li>



<li><strong>Churchill Downs, Inc.</strong> – <strong>974.770 dollar</strong></li>



<li><strong>Laurel</strong> – <strong>875.287 dollar</strong></li>



<li><strong>Caesars</strong> – <strong>750.891 dollar</strong></li>



<li><strong>Meadowlands</strong> – <strong>590.760 dollar</strong></li>



<li><strong>Del Mar Thoroughbred Club</strong> – <strong>509.442 dollar</strong></li>



<li><strong>New York Racing Association</strong> – <strong>502.500 dollar</strong></li>



<li><strong>Penn National</strong> – <strong>491.828 dollar</strong></li>



<li><strong>Parx Racing</strong> – <strong>448.268 dollar</strong></li>



<li><strong>Tampa Bay Downs</strong> – <strong>413.079 dollar</strong></li>
</ul>



<p>Hand upp den som tror att sulkysporten kommer att fortsätta på Hawthorne Race Course.</p>



<p>* Fotnot: Artikeln presenteras i dagens nummer av Harness Racing Update.</p>
