<p>Historien om <strong>Natalie Örtlund</strong> och Rommetravet blir alltmer märklig och ologisk. Igår hamnade en lärling tillhörig Örebrotravet i blickfånget och dessutom försökte Rommes ledning med ett försök att offentligt förklara sig, vilket klokt nog togs tillbaka.</p>
<p>Samtidigt publicerade sajten <a href="http://www.trottosport.se/2017/03/22/rommes-agerande-ar-ett-overgrepp/">trottosport.se</a> uppgifter om att Romme inte ens varit nära att följa den formella gången för sådana här ärenden.</p>
<p><a href="https://sulkysport.se/larling-mister-ocksa-licensen/">Indragen lärlingslicens</a> i soluppgången. Amatör istället innan solen gick ner. Så slutade onsdagen för <strong>Jimmy Wahlqvist</strong>, vilken finns med i omständigheterna runt indragningen av Rommeamatören Natalie Örtlunds licens.</p>
<p>Innan Örebrotravets sportchef <strong>Claes Broberg</strong> i tisdags stämplade ut från kontoret för att ta en veckas semester fick <strong>Barbro Lindell</strong> uppgiften att ”ta tag i” att Jimmy Wahlqvist inte längre uppfyllde kriterierna för att ha lärlingslicens. Han var lärling hos <strong>Kenneth L T Nilsson</strong> och Kenneths antal hästar på träningslistan var så lågt (fem stycken) att han inte får ha lärlingslicensierad personal.</p>
<p>På onsdagmorgonen avslutade Lindell, efter att ha pratat med Kenneth L T Nilsson, Wahlqvists lärlingslicens. Wahlqvist själv informerades inte om detta, han fick under förmiddagen reda på av Sulkysport att han inte längre skulle få köra lopp.</p>
<p>Claes Broberg var då inte tillgänglig på grund av att han var på resande fot. När sportchefen blev kontaktbar igen fick han klart för sig att indragningen av Jimmy Wahlqvists licens blivit publicerad (på sulkysport.se). Nu var det plötsligt så att Jimmy skulle ha en annan licens – en amatördito.</p>
<p>– Det finns ingen dramatik i detta och kopplingen till Natalie Örtlund-fallet är felaktig. även om jag har förståelse för att den görs med tanke på omständigheterna. Jimmy hade amatörlicens tidigare. Så kom det här att han jobbat hos Kenneth L T Nilsson medan denne varit sjukskriven, och då ändrades det till lärlingslicens. Med så få hästar som Kenneth har på listan nu är det inte formellt rätt att Jimmy ska ha lärlingslicens och då blir han amatör igen. Inga konstigheter alls, men sedan verkar det ha blivit olyckligt i kommunikationen om licensändringen, och jag kan också hålla med om att tajmingen ger intryck av det hänger ihop med Örtlund-grejen. Men det gör det alltså inte, säger Claes Broberg.</p>
<div class="factbox left minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Indragningen av Natalie Örtlunds licens								</h3>
<div class="content">
								Tisdagen den 14 mars gjorde Travarhälsan rutinkontroll hos amatörtränaren Natalie Örtlund med stall nära Romme. Natalie har nio hästar på träningslistan.<br />
Några anmärkningar gjordes gällande administrativa delar av verksamheten. En hästs hull ifrågasattes.<br />
Måndagen den 20 mars hade Rommes licenskommitté möte föranlett av de brister som uppdagats vid inspektionen. Beslutet blev licensindragning i två månader. Motiveringen var:<br />
Oklara tränarförhållanden<br />
Brister vid hantering av behandlingsjournaler<br />
Skadat travsportens anseende<br />
<em>”Beslutet gäller från den 20 mars till 20 maj och efter det ska omprövning ske; efter att en plan för hur verksamheten ska bedrivas i fortsättningen samt efter ett godkänt teoriprov med tonvikt på ST:s reglemente.</em>”, står det i beslutet.</p>
<p><a href="http://www.trottosport.se/2017/03/20/22-arig-amator-fick-licensen-indragen/">Den här artikeln</a> startade de senaste dagarnas publicitet gällande Natalie Örtlund.</p>
<p>&nbsp;							</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>
<p>Igår låg också en kort tid en artikel ute på dalatravet.se där banans chef <strong>Sven Eriksson</strong> och ordföranden <strong>Anders Jonsson</strong> ville försöka klargöra banas och licenskommitténs hantering av ärendet. Den togs dock bort, och det var nog lika bra det. Licensindragningen är ju överklagad till Svensk Travsport och att banan i det läget skulle gå ut på sin hemsida med en form av ”partsinlaga” är minst sagt anmärkningsvärt.</p>
<p>Än mer anmärkingsvärt – ja till och med stötande – blir det i ljuset av omständigheten att banans sportchef <strong>Kaj Närhinen</strong> tydligt klargjorde för Natalie Örtlund att han ansåg det olämpligt att hon publicerat en facebook-status om Travarhälsa-besöket förra veckan och ville<em> ”kommunicera face-to-face och inte via facebook”.</em></p>
<p>I <a href="http://www.trottosport.se/2017/03/22/rommes-agerande-ar-ett-overgrepp/">samma artikel </a>beskriver trottosport.se den formella gången för sådana här ärenden, något som finns att läsa på <a href="https://www.travsport.se/article/2.292/1.604371">travsport.se:</a></p>
<p><em>”Innan en licens dras in skall flera besök ha gjorts, tränaren skall också ha fått information och rådgivning. Om det går så långt att en tränare riskerar att få sin licens indragen skall denne först ges möjlighet att yttra sig.</em></p>
<p><em>– Enligt rutinen för Travarhälsan får då tränaren en underrättelse inför beslut där denne ges möjlighet att yttra sig inom 14 dagar. När tiden gått ut hålls ett möte med det berörda travsällskapet, om det gäller en b-tränare, där allt underlag i ärendet och även det eventuella yttrandet gås igenom. Därefter fattas ett beslut av travsällskapet om licensen ska dras in eller inte, beslutet kan överklagas till Svensk Travsports licenskommitté, säger Agneta Sandberg.”</em><br />
Mötet där Natalie Örtlund fick sin licens indragen, med medskicket att hon ”skulle göra om amatörtränarutbildningens teoridel”, hölls sex dagar efter inspektionen i hennes stall. Inget av det som enligt ovan enligt ST:s <strong>Agneta Sandberg</strong> krävs för att licensindragning ska vara aktuell var då uppfyllt.</p>
<blockquote><p>Innan en licens dras in skall flera besök ha gjorts</p></blockquote>
<p>Så det är frågan om licensindragningsbeslutet ens gått formellt rätt till väga. Och redan efter ett drygt dygn var också de sakliga grunder för licensindragningen som Romme angett i det kortfattade beslut om den som Natalie Örtund i måndags i praktiken söndersmulade.</p>
<p>Till <a href="https://sulkysport.se/miste-licensen-igar-olaga-intrang-idag/">sulkysport.se</a> sade Rommes sportchef <strong>Kaj Närhinen</strong> att punkten<em> ”skadat sportens anseende”</em> var en felformulering, det skulle varit <em>”olämpligt uppträdande mot funktionär”.</em> Vad som skulle varit allvarligt regelbrott (skada sportens anseende är självklart en grund för licensindragning) byttes då ut mot en reglementsförseelse (olämpligt uppträdande) som i normalfallet ger böter som påföljd.</p>
<p>På eftermiddagen publicerades på <a href="https://www.travsport.se/article/2.292/1.604278">travsport.se</a> en artikel som avslutades med orden<br />
<em>”Svensk Travsport har inte berett ett djurskyddsärende gällande detta.” </em>Det betyder att man lagt ned, inte utreder vidare, det som kontrollanterna dokumenterat gällande en påstådd undernärd häst. Inget case där heller alltså.</p>
<p>Så tog det ytterligare ungefär tre timmar innan <a href="https://www.travronden.se/nyheter/sport/wahlman-tranarbyte-ska-goras-i-rimlig-tid-101431">travronden.se</a> hade intervjuat Svensk Travsports jurist <strong>Göran Wahlman</strong> som konstaterade att påståendena om att Natalie Örtlund fört sin träningslista felaktigt heller knappast höll.</p>
<p>Hela licenskommitténs i beslutet angivna grunder (nästan) för licensindragningen föll i praktiken inom tolv timmar. Innan ens överklagandet var inlämnat.</p>
<p>Natalie Örtlunds överklagan till Svensk Travsport om licensindragningen förefaller därför på ishockeyspråk vara friläge mot öppen kasse. En fråga som blir allt svårare att värja sig för, är vad som egentligen ligger bakom att Rommes licenskommitté fattade det beslut den gjorde. Är det så enkelt att den rådande ”kulturen” på Romme inte accepterar att det kommer en ung (Natalie är 22 år) tjej utifrån, hyr stall nära banan, är framfusig och med åsikter om hur saker och ting ska vara och fungera som hon inte bangar för att öppet ventilera? Fel ålder, fel kön (!), fel attityd, fel dialekt (!?), fel plats.</p>
<blockquote><p>friläge mot öppen kasse</p></blockquote>
<p> </p>
<p>Det finns i så fall en avgrund mellan det som Svensk Travsport alldeles nyss, genom Pegasus 2020-projektet, har beslutat att man ska arbeta efter, och hur det fungerar i praktiken: <em>”Vår vision: Vi ska bli världens bästa travsport som är attraktiv för alla.”</em></p>
<p>Det som borde ha blivit en rätt ”basic” lista med formella administrativa saker att åtgärda och lösa för Natalie Örtlund efter Travhälsa-besöket; typ ”det här ska du rätta till, du har en månad på dig, sedan kontrollerar vi om det är gjort” har nu växt till något som är av rent symbolisk art. En ”liten amatörs” kamp mot hur sportslig myndighetsmakt utövas.</p>
<p>”Den som är väldigt stark måste också vara väldigt snäll”, introducerade <strong>Astrid Lindgren</strong> gällande den superstarka Pippi Långstrump. Samma budskap har sedan alla barn fått sig till livs genom <strong>Rune Andreassons</strong> världens starkaste björn Bamse.</p>
<blockquote><p>”Den som är väldigt stark måste också vara väldigt snäll”</p></blockquote>
<p>En Travarhälsa-inspektion är myndighetsutövning. En banas licenskommitté är en institution med makt. I förhållande till en 22-årig amatörlicensinnehavare är de superstarka.</p>
<p>Kanske behöver dessa delar av Pippi-böckerna och Bamse-serierna ingå i Pegasus 2020-kurslitteraturen för de som är satta att utöva makt inom svensk travadministration.</p>
<p>Och Svenslk Travsport ska kanske fundera på en reglementsändring: ska ett så allvarligt reglementsbrott som ”skadat travsportens anseende” ens få finnas med i arsenalen när en banas licenskommitté behandlar något? Borde inte ärenden av den digniteten, när de dyker upp, hanteras av den centrala administrationen?</p>
